[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6WZJG5DMS2EME60SMBPNAHV":3,"skill-same:01M6WZJG5DMS2EME60SMBPNAHV":62},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":33,"linkOnly":34,"markdownContent":35,"markdownBody":36,"frontMatter":37,"refName":38,"commitSha":39,"skillDirectory":40,"forksCount":41,"repositoryHtmlUrl":42,"repositoryHomepageUrl":43,"ownerHtmlUrl":44,"ownerBlogUrl":45,"ownerDescription":46,"updatedAt":47,"install":48,"resources":61},"01M6WZJG5DMS2EME60SMBPNAHV","vbci-memory",null,"Verona interpreter (vbci) memory management model — regions, reference counting, write barriers, dragging, cowns, and finalization. Use when working on or debugging vbci runtime memory management code.","microsoft\u002Fverona","microsoft","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F6154722?v=4","01M698VYDXZ6JW5WH3CRV650R8","Microsoft","01M6WZHTA01TB3YK5SZM938MTG",3742,"MIT","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fvbci-memory\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32],"memory","vbci memory","debugging","code","model","write","management","use","reference","memory management","runtime","interpreter","counting","when","2026-11-10 10:12:30",false,"---\nname: vbci-memory\ndescription: Verona interpreter (vbci) memory management model — regions, reference counting, write barriers, dragging, cowns, and finalization. Use when working on or debugging vbci runtime memory management code.\n---\n\n# vbci Memory Management\n\n## Overview\n\nThe Verona interpreter uses a region-based memory model with reference counting. Objects live in regions, regions form strict trees (single parent, single entry point), and cowns provide a forest of independent region trees for concurrency.\n\n## Object Locations\n\nEvery object\u002Farray has a `Location` (encoded as a tagged `uintptr_t`):\n\n| Location | Meaning | RC type | Collected by |\n|----------|---------|---------|-------------|\n| **Stack** | Stack-allocated in a frame | No RC | Frame teardown (destruct) |\n| **Frame-local** | In a frame's embedded RegionRC | Object RC | RC=0 collection, or `free_contents` for cycles |\n| **Region** | In a heap RegionRC | Object RC | RC=0 collection, or `free_contents` for cycles |\n| **Immutable** | Frozen, shareable | ARC (atomic) | ARC=0 collection |\n| **Immortal** | Primitive values, constants | No RC | Never collected |\n\n## Two Independent RC Systems\n\n### Object RC (`Header::rc`)\n\nCounts **all** incoming references to an object, regardless of source (registers, fields, anywhere). When RC hits 0, the object is collected individually via `collect()`. The region's stack_rc is irrelevant to individual object collection.\n\n- `inc\u003Cneeds_stack_rc>()`: increments object RC; if `needs_stack_rc`, also increments the region's stack_rc\n- `dec\u003Cneeds_stack_rc>()`: decrements object RC; if RC hits 0, queues for collection via `collect()`\n\nThe `needs_stack_rc` template parameter indicates whether the reference is from a register\u002Fstack\u002Fframe-local context (true) or from a field within a region (false).\n\n### Region Stack RC (`Region::stack_rc`)\n\nCounts references into the region from **outside** the region's own object graph — specifically from:\n- Frame registers\n- Fields of stack-allocated or frame-local objects\u002Farrays\n\nThis keeps entire regions alive. A region can be collected (freed as a whole) when:\n- It has **no parent** (not parented to another region, not cown-owned)\n- Its **stack_rc is 0** (no external references)\n\nStack_rc is NOT per-object — it's per-region.\n\n## Regions\n\nRegions are containers of objects that form **strict trees**:\n- Each region has at most one parent region\n- There is exactly one entry point from a parent to a child region\n- Cowns can own regions, creating a **forest** of region trees\n\n### Region Types\n- **RegionRC**: Reference-counted region with a `headers` set tracking all contained objects\n- Regions track: `stack_rc`, `parent` (with tag bits for parent type), `finalizing` flag\n\n### Region Parenting\nThe `parent` field encodes the owner:\n- `0`: no owner (root region, collectible if stack_rc == 0)\n- Pointer with no tag bits: parent is another Region\n- `parent_tag_cown`: owned by a cown\n- `parent_tag_frame_local`: frame-local region\n\n## Frame Teardown\n\nEach frame has:\n- **Stack allocations**: objects allocated with `Op::Stack` on the frame's stack area\n- **Frame-local region**: an embedded `RegionRC` for objects created with `Op::New`\n\nTeardown order:\n1. **`frame->drop()`**: Clears all registers. RC decrements may trigger individual object collection via `collect()`.\n2. **Phase 1**: Run finalizers on stack objects (via `run_sync` with readonly reference)\n3. **Phase 2**: Destruct stack objects (drop field references, no finalizer)\n4. **`free_contents()`**: Finalize and deallocate everything remaining in the frame-local region. This handles **cyclic garbage** — objects whose RC never hit 0 because they only have internal references within the region.\n\n## Dragging\n\nWhen an object in a frame-local region needs to escape (return to parent frame, be stored in a region, be sent to a cown), it is **dragged** via `drag_allocation()`:\n\n1. DFS traversal from the root object to find all reachable frame-local objects\n2. Track internal RC (edges within the dragged set) vs external RC\n3. Check that child regions can be parented (no existing owner, no cycles)\n4. Move all objects to the destination region, adjusting RCs and setting parents\n\nThe `ignore_parent` parameter allows drags during exchange: when the outgoing value's region will be unparented by `apply_out`, the drag can treat that region as unowned without actually unparenting it first.\n\n## Write Barrier (`writebarrier.h`)\n\nThe write barrier handles stores (field writes, array element writes) with a prepare\u002Fapply pattern:\n\n```\nwrite_ops\u003Cis_move>()\n    .prepare_store(store_loc)     \u002F\u002F where the store target lives\n    .prepare_out(prev_loc)        \u002F\u002F where the outgoing (old) value lives\n    .prepare_in(next_loc)         \u002F\u002F where the incoming (new) value lives\n```\n\nThen:\n- `apply_in()`: executes drag, writes value, adjusts incoming RC\u002Fstack_rc\u002Fparent\n- `apply_out()`: adjusts outgoing RC\u002Fstack_rc, unparents outgoing region\n\nKey operations planned during prepare:\n- **Incoming**: drag (frame-local → region), RC inc\u002Fclear, stack_rc adjust, region parent\n- **Outgoing**: RC dec, stack_rc adjust, region unparent\n- `drop()`: simplified version for field drops during finalization (no incoming value)\n\n### Ordering constraint\n`apply_out` runs AFTER `apply_in`. When the incoming drag needs the outgoing region to be unparented first, `ignore_parent` on `drag_allocation` resolves this without reordering.\n\n## Collection (`collect.cc`)\n\nThe `collect()` function handles deferred deallocation to avoid re-entrancy issues:\n\n- First call: sets `in_collection = true`, processes worklist\n- Nested calls (from `deallocate()` → `finalize()` → field drops → more RC=0): add to worklist, return immediately\n- Worklist processes until empty, then `in_collection = false`\n\nEach worklist item calls `deallocate()` which calls `finalize()` then frees the memory.\n\n## Cowns\n\nCowns (`verona::rt::VCown`) own a value and optionally a region:\n- `add_reference()`: stores a value in the cown, potentially dragging frame-local to a fresh region and setting cown ownership\n- `exchange()`: swaps the cown's content, handling region re-parenting with rollback on failure\n- Cown-owned regions have `parent = parent_tag_cown`\n\n## Readonly Values\n\nReadonly values always come from a readonly cown (via `Read` op or behavior cown args with read-only slots). Key properties:\n- **Cannot be mutated**: stores through readonly refs raise `BadStoreTarget`\n- **Cannot have new field references**: no object\u002Farray can create a new field pointing to a readonly value\n- **No object\u002Farray RC**: `reg_inc`\u002F`reg_dec` skip object RC and stack_rc for readonly objects\u002Farrays\n- **Cowns still need RC**: readonly cown values (`ValueType::Cown`) still need `cown->inc()`\u002F`cown->dec()` — the cown itself is ref-counted independently of its content's readonly status\n- **CownRef needs no RC**: `CownRef` values exist only as behavior arguments and are alive for the behavior's lifetime — no RC needed\n\n## Finalization\n\nObjects with a `final` method have their finalizer run during collection\u002Fteardown:\n- Called with a **read-only** reference to the object (prevents resurrection)\n- Finalizers must not mutate — stores through readonly refs raise `BadStoreTarget`\n- `Object::finalize()`: runs finalizer via `run_sync()`, then drops all field references via `writebarrier::drop()`\n- `Object::destruct()`: drops field references without running the finalizer (for stack objects after Phase 1)\n\n### Finalization ordering\nThe collector uses a two-phase approach: Phase 1 finalizes all objects (running finalizers, dropping field references), Phase 2 frees memory. This prevents use-after-free when finalizers reference sibling objects — all finalizers run before any memory is freed.\n\n## Sendability\n\nAn object is sendable if its region:\n- Has no owner (no parent region, no cown owner)  \n- Has stack_rc == 1 (only the current register references it)\n\nFrame-local objects are dragged to a fresh region first, then the region is checked for sendability. This ensures data-race freedom — only objects with exclusive ownership can be sent to behaviors.\n\n## Freezing (`freeze.cc`)\n\nFreezing converts a reachable subgraph from mutable region objects to immutable objects with ARC tracking. The region survives with any unfrozen objects.\n\n### Two entry points\n- **`freeze(Header* root)`**: Freezes reachable subgraph in a heap region. Handles frame-local roots by delegating to `freeze_local`. Returns true on success.\n- **`freeze_local(Header* root)`**: Freezes frame-local objects in place, then delegates discovered heap sub-regions to `freeze()` in phase 2.\n\n### SCC detection with rc-transfer\nUses Tarjan-style DFS with union-find. During SCC detection, `scc_union(child, rep)` transfers `child.rc - 1` to rep (subtracting the tree edge). Back edges decrement `rep.rc`. At SCC completion, `set_arc(rep->get_rc())` gives the exact external ref count without needing separate inc_arc calls.\n\nUnion-by-address (using `uintptr_t` of header as rank) with path compression gives O(α(n)) amortized.\n\n### Stack_rc adjustment\nAfter freezing, the region's stack_rc must be adjusted to account for stack references that now point to immutable objects:\n\n```\nstack_adjustment = arc_sum - frozen_cross - unfrozen_to_frozen\n```\n\n- `arc_sum`: sum of all SCC arcs (total external refs to frozen objects)\n- `frozen_cross`: cross-edges between newly-frozen SCCs (tracked via `frozen_set`)\n- `unfrozen_to_frozen`: field refs from surviving region objects to newly-frozen objects\n\n### Sub-region handling\nWhen the freeze DFS discovers an entry point to a sub-region, it pushes it to a worklist. After freezing the parent region, sub-regions are processed. Ownership is cleared only when `root == region->get_entry_point()`.\n\n### Entry point tracking\n`Region` stores a `Header* entry_point` set during `set_parent()` and `set_cown_owner()`. This is needed to:\n- Assert the single-entry-point invariant during freeze\n- Guard ownership clearing (only clear when freezing the entry point)\n\n### Location states during freeze\n| State | Location | rc\u002Farc field | Meaning |\n|-------|----------|-------------|---------|\n| UNMARKED | Region ptr | rc = field refs | Normal mutable, not yet visited |\n| PENDING | Pending tag | rc = accumulated external refs | On DFS path, SCC candidate |\n| SCC_PTR | SCC ptr to rep | unused | Union-find member, points toward root |\n| IMMUTABLE | Immutable tag | arc = external ref count | Frozen SCC root |\n\n### Immutable object lifecycle\n- `field_inc()` on immutable → `arc++`\n- `field_dec()` on immutable → `arc--`; if 0, `collect_scc()` walks all SCC members via SCC_PTR chains, finalizes, and frees\n- `reg_inc()`\u002F`reg_dec()` on immutable → only `field_inc()`\u002F`field_dec()` (no stack_rc)\n\n## Key Files\n\n| File | Purpose |\n|------|---------|\n| `header.h` | Base Header class: RC, location, region access, inc\u002Fdec |\n| `region.h` | Region struct: stack_rc, parent, ownership |\n| `region_rc.h\u002Fcc` | RegionRC: headers set, insert\u002Fremove\u002Frfree\u002Ffree_contents |\n| `location.h\u002Fcc` | Location encoding, `drag_allocation` |\n| `writebarrier.h` | Write barrier: prepare\u002Fapply pattern for stores |\n| `collect.h\u002Fcc` | Deferred collection worklist |\n| `object.h` | Object: init, finalize, destruct, deallocate |\n| `array.h` | Array: element access, finalize, deallocate |\n| `cown.h` | Cown: add_reference, exchange |\n| `value.h\u002Fcc` | Value union type: RC forwarding, location queries |\n| `register.h` | Register wrapper: ownership semantics |\n| `thread.h\u002Fcc` | Frame management, teardown, `run_sync` |\n","# vbci Memory Management\n\n## Overview\n\nThe Verona interpreter uses a region-based memory model with reference counting. Objects live in regions, regions form strict trees (single parent, single entry point), and cowns provide a forest of independent region trees for concurrency.\n\n## Object Locations\n\nEvery object\u002Farray has a `Location` (encoded as a tagged `uintptr_t`):\n\n| Location | Meaning | RC type | Collected by |\n|----------|---------|---------|-------------|\n| **Stack** | Stack-allocated in a frame | No RC | Frame teardown (destruct) |\n| **Frame-local** | In a frame's embedded RegionRC | Object RC | RC=0 collection, or `free_contents` for cycles |\n| **Region** | In a heap RegionRC | Object RC | RC=0 collection, or `free_contents` for cycles |\n| **Immutable** | Frozen, shareable | ARC (atomic) | ARC=0 collection |\n| **Immortal** | Primitive values, constants | No RC | Never collected |\n\n## Two Independent RC Systems\n\n### Object RC (`Header::rc`)\n\nCounts **all** incoming references to an object, regardless of source (registers, fields, anywhere). When RC hits 0, the object is collected individually via `collect()`. The region's stack_rc is irrelevant to individual object collection.\n\n- `inc\u003Cneeds_stack_rc>()`: increments object RC; if `needs_stack_rc`, also increments the region's stack_rc\n- `dec\u003Cneeds_stack_rc>()`: decrements object RC; if RC hits 0, queues for collection via `collect()`\n\nThe `needs_stack_rc` template parameter indicates whether the reference is from a register\u002Fstack\u002Fframe-local context (true) or from a field within a region (false).\n\n### Region Stack RC (`Region::stack_rc`)\n\nCounts references into the region from **outside** the region's own object graph — specifically from:\n- Frame registers\n- Fields of stack-allocated or frame-local objects\u002Farrays\n\nThis keeps entire regions alive. A region can be collected (freed as a whole) when:\n- It has **no parent** (not parented to another region, not cown-owned)\n- Its **stack_rc is 0** (no external references)\n\nStack_rc is NOT per-object — it's per-region.\n\n## Regions\n\nRegions are containers of objects that form **strict trees**:\n- Each region has at most one parent region\n- There is exactly one entry point from a parent to a child region\n- Cowns can own regions, creating a **forest** of region trees\n\n### Region Types\n- **RegionRC**: Reference-counted region with a `headers` set tracking all contained objects\n- Regions track: `stack_rc`, `parent` (with tag bits for parent type), `finalizing` flag\n\n### Region Parenting\nThe `parent` field encodes the owner:\n- `0`: no owner (root region, collectible if stack_rc == 0)\n- Pointer with no tag bits: parent is another Region\n- `parent_tag_cown`: owned by a cown\n- `parent_tag_frame_local`: frame-local region\n\n## Frame Teardown\n\nEach frame has:\n- **Stack allocations**: objects allocated with `Op::Stack` on the frame's stack area\n- **Frame-local region**: an embedded `RegionRC` for objects created with `Op::New`\n\nTeardown order:\n1. **`frame->drop()`**: Clears all registers. RC decrements may trigger individual object collection via `collect()`.\n2. **Phase 1**: Run finalizers on stack objects (via `run_sync` with readonly reference)\n3. **Phase 2**: Destruct stack objects (drop field references, no finalizer)\n4. **`free_contents()`**: Finalize and deallocate everything remaining in the frame-local region. This handles **cyclic garbage** — objects whose RC never hit 0 because they only have internal references within the region.\n\n## Dragging\n\nWhen an object in a frame-local region needs to escape (return to parent frame, be stored in a region, be sent to a cown), it is **dragged** via `drag_allocation()`:\n\n1. DFS traversal from the root object to find all reachable frame-local objects\n2. Track internal RC (edges within the dragged set) vs external RC\n3. Check that child regions can be parented (no existing owner, no cycles)\n4. Move all objects to the destination region, adjusting RCs and setting parents\n\nThe `ignore_parent` parameter allows drags during exchange: when the outgoing value's region will be unparented by `apply_out`, the drag can treat that region as unowned without actually unparenting it first.\n\n## Write Barrier (`writebarrier.h`)\n\nThe write barrier handles stores (field writes, array element writes) with a prepare\u002Fapply pattern:\n\n```\nwrite_ops\u003Cis_move>()\n    .prepare_store(store_loc)     \u002F\u002F where the store target lives\n    .prepare_out(prev_loc)        \u002F\u002F where the outgoing (old) value lives\n    .prepare_in(next_loc)         \u002F\u002F where the incoming (new) value lives\n```\n\nThen:\n- `apply_in()`: executes drag, writes value, adjusts incoming RC\u002Fstack_rc\u002Fparent\n- `apply_out()`: adjusts outgoing RC\u002Fstack_rc, unparents outgoing region\n\nKey operations planned during prepare:\n- **Incoming**: drag (frame-local → region), RC inc\u002Fclear, stack_rc adjust, region parent\n- **Outgoing**: RC dec, stack_rc adjust, region unparent\n- `drop()`: simplified version for field drops during finalization (no incoming value)\n\n### Ordering constraint\n`apply_out` runs AFTER `apply_in`. When the incoming drag needs the outgoing region to be unparented first, `ignore_parent` on `drag_allocation` resolves this without reordering.\n\n## Collection (`collect.cc`)\n\nThe `collect()` function handles deferred deallocation to avoid re-entrancy issues:\n\n- First call: sets `in_collection = true`, processes worklist\n- Nested calls (from `deallocate()` → `finalize()` → field drops → more RC=0): add to worklist, return immediately\n- Worklist processes until empty, then `in_collection = false`\n\nEach worklist item calls `deallocate()` which calls `finalize()` then frees the memory.\n\n## Cowns\n\nCowns (`verona::rt::VCown`) own a value and optionally a region:\n- `add_reference()`: stores a value in the cown, potentially dragging frame-local to a fresh region and setting cown ownership\n- `exchange()`: swaps the cown's content, handling region re-parenting with rollback on failure\n- Cown-owned regions have `parent = parent_tag_cown`\n\n## Readonly Values\n\nReadonly values always come from a readonly cown (via `Read` op or behavior cown args with read-only slots). Key properties:\n- **Cannot be mutated**: stores through readonly refs raise `BadStoreTarget`\n- **Cannot have new field references**: no object\u002Farray can create a new field pointing to a readonly value\n- **No object\u002Farray RC**: `reg_inc`\u002F`reg_dec` skip object RC and stack_rc for readonly objects\u002Farrays\n- **Cowns still need RC**: readonly cown values (`ValueType::Cown`) still need `cown->inc()`\u002F`cown->dec()` — the cown itself is ref-counted independently of its content's readonly status\n- **CownRef needs no RC**: `CownRef` values exist only as behavior arguments and are alive for the behavior's lifetime — no RC needed\n\n## Finalization\n\nObjects with a `final` method have their finalizer run during collection\u002Fteardown:\n- Called with a **read-only** reference to the object (prevents resurrection)\n- Finalizers must not mutate — stores through readonly refs raise `BadStoreTarget`\n- `Object::finalize()`: runs finalizer via `run_sync()`, then drops all field references via `writebarrier::drop()`\n- `Object::destruct()`: drops field references without running the finalizer (for stack objects after Phase 1)\n\n### Finalization ordering\nThe collector uses a two-phase approach: Phase 1 finalizes all objects (running finalizers, dropping field references), Phase 2 frees memory. This prevents use-after-free when finalizers reference sibling objects — all finalizers run before any memory is freed.\n\n## Sendability\n\nAn object is sendable if its region:\n- Has no owner (no parent region, no cown owner)  \n- Has stack_rc == 1 (only the current register references it)\n\nFrame-local objects are dragged to a fresh region first, then the region is checked for sendability. This ensures data-race freedom — only objects with exclusive ownership can be sent to behaviors.\n\n## Freezing (`freeze.cc`)\n\nFreezing converts a reachable subgraph from mutable region objects to immutable objects with ARC tracking. The region survives with any unfrozen objects.\n\n### Two entry points\n- **`freeze(Header* root)`**: Freezes reachable subgraph in a heap region. Handles frame-local roots by delegating to `freeze_local`. Returns true on success.\n- **`freeze_local(Header* root)`**: Freezes frame-local objects in place, then delegates discovered heap sub-regions to `freeze()` in phase 2.\n\n### SCC detection with rc-transfer\nUses Tarjan-style DFS with union-find. During SCC detection, `scc_union(child, rep)` transfers `child.rc - 1` to rep (subtracting the tree edge). Back edges decrement `rep.rc`. At SCC completion, `set_arc(rep->get_rc())` gives the exact external ref count without needing separate inc_arc calls.\n\nUnion-by-address (using `uintptr_t` of header as rank) with path compression gives O(α(n)) amortized.\n\n### Stack_rc adjustment\nAfter freezing, the region's stack_rc must be adjusted to account for stack references that now point to immutable objects:\n\n```\nstack_adjustment = arc_sum - frozen_cross - unfrozen_to_frozen\n```\n\n- `arc_sum`: sum of all SCC arcs (total external refs to frozen objects)\n- `frozen_cross`: cross-edges between newly-frozen SCCs (tracked via `frozen_set`)\n- `unfrozen_to_frozen`: field refs from surviving region objects to newly-frozen objects\n\n### Sub-region handling\nWhen the freeze DFS discovers an entry point to a sub-region, it pushes it to a worklist. After freezing the parent region, sub-regions are processed. Ownership is cleared only when `root == region->get_entry_point()`.\n\n### Entry point tracking\n`Region` stores a `Header* entry_point` set during `set_parent()` and `set_cown_owner()`. This is needed to:\n- Assert the single-entry-point invariant during freeze\n- Guard ownership clearing (only clear when freezing the entry point)\n\n### Location states during freeze\n| State | Location | rc\u002Farc field | Meaning |\n|-------|----------|-------------|---------|\n| UNMARKED | Region ptr | rc = field refs | Normal mutable, not yet visited |\n| PENDING | Pending tag | rc = accumulated external refs | On DFS path, SCC candidate |\n| SCC_PTR | SCC ptr to rep | unused | Union-find member, points toward root |\n| IMMUTABLE | Immutable tag | arc = external ref count | Frozen SCC root |\n\n### Immutable object lifecycle\n- `field_inc()` on immutable → `arc++`\n- `field_dec()` on immutable → `arc--`; if 0, `collect_scc()` walks all SCC members via SCC_PTR chains, finalizes, and frees\n- `reg_inc()`\u002F`reg_dec()` on immutable → only `field_inc()`\u002F`field_dec()` (no stack_rc)\n\n## Key Files\n\n| File | Purpose |\n|------|---------|\n| `header.h` | Base Header class: RC, location, region access, inc\u002Fdec |\n| `region.h` | Region struct: stack_rc, parent, ownership |\n| `region_rc.h\u002Fcc` | RegionRC: headers set, insert\u002Fremove\u002Frfree\u002Ffree_contents |\n| `location.h\u002Fcc` | Location encoding, `drag_allocation` |\n| `writebarrier.h` | Write barrier: prepare\u002Fapply pattern for stores |\n| `collect.h\u002Fcc` | Deferred collection worklist |\n| `object.h` | Object: init, finalize, destruct, deallocate |\n| `array.h` | Array: element access, finalize, deallocate |\n| `cown.h` | Cown: add_reference, exchange |\n| `value.h\u002Fcc` | Value union type: RC forwarding, location queries |\n| `register.h` | Register wrapper: ownership semantics |\n| `thread.h\u002Fcc` | Frame management, teardown, `run_sync` |\n",{"name":5,"description":7},"main","e9256534317bd40707e7e78ba022b8bcd0eb6577",".agents\u002Fskills\u002Fvbci-memory",173,"https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona","https:\u002F\u002Fmicrosoft.github.io\u002Fverona\u002F","https:\u002F\u002Fgithub.com\u002Fmicrosoft","https:\u002F\u002Fopensource.microsoft.com","Open source projects and samples from Microsoft","2026-11-13 21:03:28",{"source":8,"skillName":5,"commands":49,"prompt":59,"zipAvailable":60},[50,53,56],{"tool":51,"command":52},"npx","npx skills add microsoft\u002Fverona --skill vbci-memory",{"tool":54,"command":55},"bunx","bunx skills add microsoft\u002Fverona --skill vbci-memory",{"tool":57,"command":58},"pnpm","pnpm dlx skills add microsoft\u002Fverona --skill vbci-memory","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fvbci-memory\u002FSKILL.md",true,[],[63,84,102,120,125,146],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":33},"01M6WZM7JFY7GMHE7YTCC4K0ZS","verona-type-inference","Verona compiler type inference model — bidirectional refinement, per-function inference, lambda\u002Fcontext propagation, algebraic and structural typing, generics, and debugging. Use when changing or debugging `vc\u002Fpasses\u002Finfer.cc` or investigating type inference failures.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fverona-type-inference\u002FSKILL.md",[],[70,71,72,73,32,74,75,76,77,78,79,80,26,81,23,82,83,21],"verona type inference","type","inference","cc","vc","refinement","typing","infer","false","propagation","structural","context","lambda","compiler",{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":33},"01M6WZM48VF2FFX61WFYTD5XVJ","verona-conventions","Verona compiler coding conventions, C++ style, trieste patterns, and project structure. Applies when writing or reviewing Verona compiler code.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fverona-conventions\u002FSKILL.md",[],[91,92,93,78,94,95,96,97,98,83,22,99,100,32,101],"verona conventions","conventions","writing","project","c++","structure","patterns","coding","project structure","style","coding conventions",{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":108,"publishedAt":33},"01M6WZM0Z3CTQG1ZRV9V2DZX9W","verona-coding","Patterns, pitfalls, and idioms for writing Verona source code (.v files). Use when writing library code, _builtin types, or user programs.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fverona-coding\u002FSKILL.md",[],[109,98,32,110,111,112,113,114,97,115,116,117,26,118,119,22,93],"verona coding","source code","source","for","pitfalls","types","builtin","files","idioms","user","library",{"skillNo":121,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":122,"categories":123,"keywords":124,"publishedAt":33},"01M6WZKWW9ZCQ1EXZYR4GZ00YF","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fvbci-memory\u002FSKILL.md",[],[20,19,29,32,31,30,28,27,26,25,24,23,22,21],{"skillNo":126,"name":127,"nameZh":6,"description":128,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":129,"categories":130,"keywords":131,"publishedAt":33},"01M6WZKP04VZBWRZ2449FBRDNY","testsuite","Verona compiler test suite infrastructure — running tests, updating golden files, verifying pass completeness, checking error codes. Use when debugging test failures, regenerating golden files, or understanding the test framework.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Ftestsuite\u002FSKILL.md",[],[127,26,32,132,133,134,135,136,137,138,116,139,140,83,141,142,21,143,144,145],"error codes","suite","codes","error","golden","completeness","tests","test suite","running","running tests","framework","infrastructure","test framework","test",{"skillNo":147,"name":148,"nameZh":6,"description":149,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":150,"categories":151,"keywords":157,"publishedAt":33},"01M6WZKGQY812K6W0R89Y7HD9T","review","Run a principle-based code review on the current branch. Use when the user asks for a review, or at mandatory review checkpoints (after planning, after implementation before PR).","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fverona\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Freview\u002FSKILL.md",[152],{"categoryNo":153,"categoryName":154,"taxonomyType":155,"taxonomyTypeDesc":156},"01JBSEEDCAT000000000000007","代码审查","SCENARIO","使用场景",[148,158,159,160,161,162,22,32,112,163,118,26,164,165,166],"planning","branch","code review","pr","run","at","checkpoints","implementation","base"]