nccgs 2.0.0-rc.3 → 2.1.0

package/.claude/nccgs/MEMORY.md

@@ -1,8 +1,10 @@
 # NCCGS — portable framework decisions
 
 NCCGS means **New Claude Code Game Studio** and targets **Claude Code**.
-This is the public 2.0.0-rc.3 release candidate, distributed through npm's next tag.
-It is not stable promotion. The package README and changelog describe release scope.
+This is the unpublished 2.1.0 source, adding reversible project uninstallation.
+The earlier 2.0.0 release was published on 2026-10-28; its archive is unchanged.
+Local preparation does not change npm tags. Native qualification remains scoped
+to its frozen archives; see README.md and CHANGELOG.md for evidence boundaries.
 Project-specific authorizations, provider sessions, budgets and internal development
 history are retained separately, outside the public package. Nothing in this file
 authorizes spending, provider access or changes to a user's project by itself.
@@ -19,6 +21,9 @@ authorizes spending, provider access or changes to a user's project by itself.
   remains unknown. Never infer execution from a requested alias or a handoff marker.
 - Preserve failed attempts, negative reviews, task history, evidence and consumed
   allowances. An update, migration, retry or new report must not reset spent budgets.
+- Uninstall only from an external terminal after sessions and owned work stop.
+  Preserve game source, custom files and .nccgs history/budgets. Uninstall never
+  closes tasks, waives review/acceptance or authorizes deleting retained records.
 - Known-solution or contaminated benchmark baselines remain reference-only; do not
   score them as independent NCCGS runs.
 

package/.claude/nccgs/VERSION

@@ -1 +1 @@
-2.0.0-rc.3
+2.1.0

package/.claude/nccgs/packages/ponytail/README.md

@@ -41,6 +41,6 @@ existing migration-review process. No separate installation is needed.
 
 These are agent instructions, not a semantic acceptance gate or a guarantee that
 a model follows them. Existing NCCGS ownership, budgets, evidence, independent
-review and closure gates remain authoritative. This package does not repair the
-separate standalone design/readiness workflow gap. Its effect on delivery quality,
+review and closure gates remain authoritative. Standalone design and readiness
+follow the separate design lifecycle protocol. This package's effect on delivery quality,
 time and token use requires fresh real Claude Code evaluation.

package/.claude/nccgs/protocols/agent-contract.md

@@ -56,13 +56,19 @@ with evidence and unresolved findings; do not spend more rounds or infer approva
 General context/time guidance is advisory; task review-round limits are enforced
 separately. A bounded repair packet additionally enforces its tool-call allowances
 and deadline at each tool admission. Its chosen solution, exact source files and
-handoff are the assignment. No shell, MCP, web, nested delegation or unplanned
-experiments are allowed in that repair worker; return PARTIAL if diagnosis is still
+handoff are the assignment. General shell, MCP, web, nested delegation and unplanned
+experiments are blocked. A typed Unity packet may permit only its fixed
+`repair-editor` wrapper; follow [bounded repair](bounded-repair.md). Return PARTIAL if diagnosis is still
 needed. The coordinator owns verification after the edits. Follow the injected
 packet and use remaining tool allowances to hand off before native turn exhaustion.
 
 ## Required handoff
 
+For a [planned slice](task-slices.md), follow its injected objective, exact files,
+dependency dispatches and original criterion definitions. Keep global constraints.
+Return a complete bounded handoff or honest PARTIAL; only the coordinator records
+the integrated task. A slice handoff is not acceptance and grants no fresh budget.
+
 When the reservation declares handoffPaths, write a concise draft to the assigned
 path early, before extended investigation. Start it with `NCCGS-HANDOFF: PARTIAL`.
 Update it as facts become available. Reserve your final few turns for the handoff;
@@ -76,6 +82,13 @@ says COMPLETE. For every review assignment follow [review handoff](review-handof
 the reviewer owns the structured verdict and explicit remaining conditions; a
 conditional PASS is not permitted under the new standalone review policy.
 
+Use the supplied PARTIAL template when available. Before returning, non-repair
+workers may run the fixed read-only `task handoff-validate` command for their own
+declared handoff. It catches structural errors while the worker can still correct
+its draft; VALID is not completion or acceptance. Run it as a plain
+`node .claude/nccgs/tools/task.mjs` invocation. Repair workers keep their existing
+tool budget and no-shell boundary. See [handoff operations](../../../docs/HANDOFF-AUTOMATION.md).
+
 For unfinished work, leave PARTIAL with exact next steps and return. Continuation
 uses a fresh foreground reservation and fresh handoff path within the existing
 remaining dispatch/purpose budget. The coordinator must carry forward the previous

package/.claude/nccgs/protocols/bounded-repair.md

@@ -1,9 +1,12 @@
-# Bounded source repair — 2.0 RC
+# Bounded repair — source edits and Unity operations
+
+Typed Unity packets below ship in the **prepared, unpublished 2.0.0 stable package**.
+Schema-1 packets and existing reservations retain their original behavior and limits.
 
 The Unity phase-2 retest exhausted a repair worker's 22 native turns while exploring
 parameters in a scratch harness. It made no gameplay change and left a PARTIAL
 handoff. A protected dispatch slot alone did not reserve time to deliver an edit.
-Fresh repair reservations now require a concrete source-edit packet and durable
+Fresh repair reservations require a concrete repair packet and durable
 tool admission limits. Existing failed cases and legacy reservations stay unchanged.
 
 ## Prepare the decision before spending the repair slot
@@ -23,6 +26,8 @@ additional reads loading that package or reopen exploration to optimize diff siz
 Copy `.nccgs/templates/repair-packet.json` into
 `.nccgs/evidence/work-packets/UNIQUE.json` and replace every placeholder:
 
+This is the unchanged schema-1 source-edit format:
+
 - `taskId`, `contractHash`, `sourceSnapshot`: current task and snapshot from the CLI.
 - `problem`, `solution`: concise failure and already-chosen correction.
 - `changes`: 1–4 exact existing source files, each with a concrete instruction.
@@ -35,6 +40,117 @@ Copy `.nccgs/templates/repair-packet.json` into
   including 6 reads/searches, 3 separate handoff writes, and 600000 ms from claim.
   The packet is at most 16 KiB. Limits cannot be raised in the request.
 
+## Select a Unity repair profile when needed
+
+Use a **fresh schema-2 packet**, never change an already reserved packet or relabel
+a repair as delivery. The existing negative-feedback requirement and aggregate
+repair/QA/review allowances apply to every profile.
+
+| Profile | Exact files | Work calls / reads | Handoff writes | Deadline |
+|---|---:|---:|---:|---:|
+| schema 1, source edit | 1–4 existing | 12 / 6 | 3 | 10 minutes |
+| schema 2, `unity-code` | 1–8 edit/create | 24 / 12 | 3 | 15 minutes |
+| schema 2, `unity-editor` | 1–8 edit/create | 20 / 8 | 3 | 15 minutes |
+
+These are ceilings, not targets, extra native turns or extensions to task-wide
+time/cost/dispatch budgets. Packet budget fields may lower them. Schema-2 packets
+are at most 32 KiB. Larger or unresolved work returns PARTIAL for a new bounded
+decision within remaining allowances; no automatic retry or budget reset.
+
+Start from `.nccgs/templates/repair-unity-code.json` or
+`.nccgs/templates/repair-unity-editor.json`. Keep the common identity, problem,
+chosen solution, context and full verification list. Add `repairType` and an
+explicit `operation: "edit"` or `"create"` to every change.
+
+- `unity-code`: C#, assembly definitions/references, shaders/includes, UXML and USS
+  under `Assets/`. Structured file edits are allowed only for these exact files.
+  Include a focused regression file when the correction needs one.
+- `unity-editor`: scenes, prefabs, assets, materials, controllers and animations
+  under `Assets/`. Apply and save through the pinned Editor operations only;
+  Write/Edit/MultiEdit cannot edit these assets or their metadata.
+  A coupled correction may also list code files and edit those with structured
+  file tools in the same packet, within the shared eight-file/work allowance.
+- Existing targets need valid companion `.meta` GUIDs. New targets and their
+  metadata must both be absent at reservation. Parents must already exist.
+  New folders, deletion/renaming, packages and ProjectSettings are outside these
+  profiles; do not smuggle them into an Editor script or widen writePaths.
+- `writePaths` lists exactly the changed targets, not their metadata or directories.
+  The scope guard also tracks each target's Unity-generated companion `.meta`.
+  Preserve all existing GUIDs. Never invent or hand-write metadata.
+
+Typed Unity repair has exclusive project ownership until it finishes or is
+externally reconciled. A captured source inventory rejects undeclared created,
+changed or deleted files, including unrelated import side effects. This is a
+post-operation guard, not a rollback or an OS sandbox. Keep other project writers
+idle; use a clean Editor state with the exact target scene/prefab selected in the
+operation, never depend on an unspecified active scene.
+
+## Pin Editor steps before dispatch
+
+`unity.steps` is an ordered array of up to four entries. Existing-code-only packets
+may use `[]`. New code needs an import step; every `unity-editor` packet needs at
+least one Editor step. Finish import/save and generated metadata **before the
+worker returns**, so the runtime observation covers the same source as verification.
+
+The supported adapter is the installed **Unity CLI** and its connected Editor
+commands. Use the bundled [Unity CLI guidance](../../skills/unity-cli/SKILL.md)
+and the specific official Unity skill for the chosen operation during preparation.
+Use existing discovery captured by delivery or operator preflight for this project;
+do not guess commands or install/upgrade tooling inside repair. When steps are
+present, pin that discovery as `unity.capabilities: {path, sha256}` under evidence.
+Discovery context is not provider or acceptance evidence. MCP names from another
+integration are not interchangeable with this adapter.
+
+Each step contains `id`, a discovered `command`, positional `arguments` and
+`timeoutMs` from 1000 to 60000. No argument may begin with `-`: project routing,
+timeouts and global flags are supplied by the runner. New 2.0.0 reservations require
+the discovered **eval** command with one C# statement body using fully qualified
+types for exact named assets; top-level using directives are rejected.
+The pinned **loaded-scenes-clean-v1** policy prepends a check in that same Editor
+eval, before the packet body. Any loaded dirty scene (including untitled and
+non-active additive scenes) returns a correlated refusal. No auto-save, discard
+or scene switch occurs. The receipt records the blocked scene as a failed step;
+the worker returns PARTIAL, retains the attempt and lets the owner resolve work.
+A new eligible packet consumes normal quota; a blocked step never replays itself.
+Legacy reservations retain their original pinned invocation without retroactive
+guard injection. The guard checks entry state; review the entire body, including
+any later scene switches, and save only explicitly owned changes.
+Review the body during packet preparation; pinning code does not make arbitrary
+C# safe. The worker cannot change it or substitute another command.
+
+The injected prompt supplies foreground Bash inputs of this shape:
+
+```json
+{
+  "command": "node .claude/nccgs/tools/task.mjs repair-editor --id TASK --dispatch DISPATCH_ID --step STEP_ID",
+  "timeout": 35000
+}
+```
+
+The tool timeout must be at least the step timeout plus 5000 ms, at most 120000 ms.
+Use one plain invocation. The runner requires the correlated worker's prior tool
+admission, launches `unity command` without a shell, fixes `--project-path` to the
+current project's real path and uses finite timeouts. It does not open an Editor,
+install a package, create a detached service or grant native permissions.
+
+A step gets a durable started record before execution and one original receipt
+under `.nccgs/evidence/repair-operations/`. Repeating its ID never executes it again.
+`EXECUTED` means the CLI returned zero and the source scope check passed; inspect
+its actual output. It is **not** a compile/test result or acceptance PASS. Long
+compile/EditMode/PlayMode/build checks stay with the coordinator's managed jobs.
+
+An interrupted, timed-out or nonzero Editor call may still have effects in the
+resident Editor. Its dispatch stays UNCERTAIN and keeps ownership. Write the
+remaining PARTIAL handoff, preserve the receipt and stop. An external operator must
+confirm the operation stopped and reconcile the original attempt before another
+writer can start. Missing CLI executables are recorded as failed without claiming
+Editor execution. No path rolls back user files or refunds calls/attempts.
+If the native worker returns first, its runtime observation, usage and partial
+handoff are retained while the repair stays UNCERTAIN. Duplicate completion events
+reuse that observation; they neither double-count usage nor release ownership.
+
+## Reserve the chosen packet
+
 The reservation must contain the packet path, exactly matching writePaths, and one
 fresh handoff path. It still needs recorded negative feedback and eligible remaining
 repair capacity within the original aggregate budget:
@@ -66,11 +182,10 @@ Direct writes to pinned packet/context evidence are refused even after completio
 
 ## Execute and hand off
 
-The worker may Read/Grep/Glob inside the project and Write/Edit/MultiEdit the exact
-source files. The assigned handoff is the only evidence file it can edit. Shells,
-MCP, web tools, nested agents and other tools are refused for this repair protocol.
-Editor/asset operations requiring Unity tools need a different properly scoped
-assignment; do not relabel repair as delivery to evade these limits.
+The worker may Read/Grep/Glob inside the project and use only the selected profile's
+edits or fixed Editor steps. The assigned handoff is the only evidence file it can
+edit. General shell commands, MCP, web and nested agents are refused. Schema 1 has
+no shell exception; schema 2 permits only its fixed `repair-editor` wrapper.
 
 Write `NCCGS-HANDOFF: PARTIAL` early. Apply the chosen correction, then replace that
 line with `NCCGS-HANDOFF: COMPLETE` only when the assigned edits are finished.
@@ -98,6 +213,9 @@ The coordinator then runs declared checks with `task verify`, collects their ori
 receipts, records the work stage and dispatches protected QA and independent review
 when eligible. Failing measurements still block PASS and DONE. No helper exit code
 or handoff marker substitutes for measured acceptance.
+New implementation records preserve prior negative review and task history. A fresh
+independent reviewer still owns its exact verdict and conditions. External/manual
+acceptance gates remain separate; Editor receipts cannot satisfy measured criteria.
 
 ## Validation and rollout boundary
 
@@ -112,7 +230,17 @@ the original cap. They establish framework behavior, not actual Claude performan
 Unity gameplay viability, provider usage or token savings. A new real Claude/Unity
 acceptance run is still required. NCCGS is a workflow guard, not an OS sandbox or
 protection against malicious code, falsified measurements or externally edited ledgers.
+Typed Unity tests use synthetic source/metadata and an injected fake Editor process,
+plus an actual missing-executable CLI failure. They do not launch Unity or Claude.
+Profile capacities, CLI compatibility and delivery efficiency still need a fresh
+authorized native evaluation; historical game cases remain frozen.
 
 Native hook output uses `PreToolUse.hookSpecificOutput.updatedInput` for the packet
 and `additionalContext` for remaining counts, without granting native permissions.
 See the [official Claude Code hooks reference](https://code.claude.com/docs/en/hooks#pretooluse-decision-control).
+
+## External Editor stop handoff
+
+Publish the original operator start/shutdown/stop receipts into reviewer-readable
+project evidence before handing off. Preserve sealed cases through a separate
+addendum; never recreate or overwrite historical process facts. See the installed `editor-session-evidence.mjs` helper and `editor-session-evidence.md` protocol.

package/.claude/nccgs/protocols/editor-session-evidence.md

@@ -0,0 +1,52 @@
+# Editor lifecycle evidence visible to the reviewer
+
+An external operator may own a Unity Editor while native workers run bounded
+operations. Keep ownership with that operator. Before handing the task to review,
+publish the operator's existing start, graceful shutdown command and settled stop
+receipts under the project's `.nccgs/evidence/editor-control/` directory.
+An external artifact directory alone is insufficient when the reviewer can only
+read the project tree.
+
+Use the installed helper from the external operator's existing harness:
+
+```js
+import { publishEditorSessionEvidence } from './.claude/nccgs/tools/editor-session-evidence.mjs';
+const reference = publishEditorSessionEvidence(project, {
+  sourceProject: project,
+  startFile: absoluteStartReceipt,
+  stopFile: absoluteStopReceipt,
+  shutdownFile: absoluteShutdownCommandReceipt
+});
+```
+
+The supported receipt format is the Windows owned-Editor harness format: start
+has `at`, `project`, and `identity` (`pid`, `windowsJob`, `groupName`); stop has the
+same identity, `state: "dead"`, `forced: false`, and `result: {code: 0, signal: null}`.
+The shutdown command receipt has `at`, fixed Unity `args` with the exact
+`--project-path` and `UnityEditor.EditorApplication.Exit(0)`, its own owned CLI
+identity, `treeState: "dead"`, `code: 0`, and `signal: null`.
+
+The helper checks ownership/project consistency, event order and reported normal
+settlement. It copies the three original files byte for byte, adds SHA-256
+references, and returns the reference to an immutable receipt bundle. Existing
+bundle IDs cannot be overwritten. Include that reference in the coordinator's
+review handoff alongside the ordinary managed-check receipts.
+
+This publisher performs no process operation or live process probe. The operator
+must still verify its owned group is dead using the existing process manager.
+Forced, failed, live or uncertain stops retain their original evidence and cannot
+be published as a normal stop by this helper. A copied receipt is not a new stop,
+native worker execution, a reviewer verdict, or acceptance evidence for gameplay.
+Untrusted receipt contents never authorize commands. Other producer formats need
+an explicit adapter and qualification; do not invent observations to fit this one.
+
+When the original case is already sealed, publish to a separate addendum project
+and pass the original absolute `sourceProject`. The bundle marks itself as a
+historical import. Keep the original task, findings, costs and hashes untouched;
+a fresh independent reviewer assesses the addendum without rewriting the old
+verdict. Do not restart the Editor merely to manufacture a replacement receipt.
+
+For future runs, publish after every externally controlled normal stop, including
+the stop after resolving an unsaved-scene refusal, before the next native handoff.
+This evidence step does not grant save/discard authority, expand worker scope,
+waive any check, or enlarge the original total budget.

package/.claude/nccgs/protocols/orchestration.md

@@ -6,7 +6,8 @@ Use this protocol when work benefits from more than one studio role.
 2. Separate decision work, implementation work, and independent verification.
 3. Assign one accountable owner to every output and writable path.
 4. Express dependencies as a directed acyclic graph.
-5. Run independent read-only analysis in parallel; serialize overlapping writes.
+5. Schedule independent work by dependency and ownership. In standalone 2.0.0,
+   launch foreground calls sequentially and collect each final result before the next.
 6. Stop dependent work when an upstream contract is unresolved.
 
 Default maximum subagent depth is one. The primary session composes the graph,
@@ -40,7 +41,7 @@ work cannot bypass this sequence. See [the handoff protocol](astra-claude.md).
 Use `nccgs-task-scout` only to close a named factual gap. Do not launch a scout,
 design consultation, or extra reviewer when existing evidence already answers the
 question. Each reviewer must cover a distinct risk. Preserve one accountable
-implementer even when independent support work runs in parallel.
+implementer even when support spans multiple specialists.
 
 Keep only one reviewer in flight per task. Standalone checks work-stage readiness
 before reserving review and again before launch. A rejected launch is automatically
@@ -58,9 +59,10 @@ explicit external extension, never automatic approval.
 
 Native agent `maxTurns` comes from the installed role frontmatter; a larger
 `Agent.max_turns` request is not evidence that the role cap increased. Templates
-are authoritative and policy compilation synchronizes the registry. Designer,
-gameplay/Unity implementation and review roles have bounded allowances of 48,
-120 and 64 turns respectively; lighter scout/FAST roles keep their short budgets.
+are authoritative and policy compilation synchronizes the registry. Read the
+[generated turn-ceiling table](../routing.generated.md) rather than copying limits
+into assignments. Check installed frontmatter and session overrides before launch;
+these ceilings neither extend task budgets nor establish observed execution.
 
 An external operator can reallocate a pinned dispatch limit with `task
 extend-dispatch --id TASK --request FILE`. The request must contain

package/.claude/nccgs/protocols/review-handoff.md

@@ -1,5 +1,11 @@
 # Reviewer-owned verdict and remaining conditions
 
+For a reservation with `handoffTransport: "native-result"`, return the entire
+Markdown handoff as one final text block and do not write a file. The native hook
+copies it verbatim into the single declared fresh handoff path. The exact same
+review contract, independent identity and gates below still apply. Other
+reservations retain the existing file-writing workflow.
+
 New standalone installs enable `reviewContractRequired: true`. The completed
 review dispatch must pin the same Markdown handoff used as the review stage's
 `evidence`. The reviewer writes exactly one `nccgs-review` fenced JSON block:
@@ -28,6 +34,16 @@ Prose explains the evidence, scope and limits; the block is the authoritative
 verdict, assessment, findings and remaining conditions. Coordinator stage input
 must copy these four fields exactly, including an explicit `conditions` array.
 
+Use `task dispatch-prompt --id TASK --dispatch ID` to prepare the registered
+assignment and a PARTIAL draft. Before returning, the running reviewer can call
+the fixed `task handoff-validate --id TASK --dispatch ID --file PATH` operation
+for its own declared handoff. Correct structural errors in that draft while the
+invocation is still active. VALID checks structure only; it never approves work.
+After native completion, the coordinator uses `task record-review --id TASK
+--dispatch ID --file PATH` to copy the pinned result through the existing review
+gate without retyping its fields. Run each as one plain invocation of
+`node .claude/nccgs/tools/task.mjs`. See [handoff operations](../../../docs/HANDOFF-AUTOMATION.md).
+
 PASS requires `conditions: []`. If acceptance still depends on a diff, test,
 source read or other check, return BLOCKED or CHANGES_REQUIRED with that condition.
 A finished negative review may mark its handoff COMPLETE. Do not write a conditional
@@ -44,7 +60,7 @@ remaining allowance cannot fund the required follow-up.
 
 For a broad delivery review, check the effective native role `maxTurns` before
 dispatch. A number in the assignment prompt does not override the role's limit.
-The shipped reviewer allows up to 200 turns; this is a ceiling, not a target.
+Read the [generated native ceilings](../routing.generated.md); a ceiling is not a target.
 Keep session cost, time and dispatch limits active. Index current receipts, raw
 files and source changes before review, and use focused reads instead of repeatedly
 loading whole histories. Write a truthful PARTIAL handoff early and update it as

package/.claude/nccgs/protocols/standalone-gates.md

@@ -1,8 +1,10 @@
-# NCCGS 2.0 RC — implementation and operation
+# NCCGS 2.0.0 — implementation and operation
 
-Version: **2.0.0-rc.3**. Target executor: **Claude Code**.
-Framework tests and scoped native delivery evidence exist. Fresh end-to-end
-qualification of this exact RC and published-1.3 upgrade qualification are pending. Read [MEMORY.md](../MEMORY.md) before interpreting evaluation results.
+Version: **2.0.0**. Target executor: **Claude Code**.
+Framework tests and scoped native delivery evidence exist. A new full Unity task
+through this exact stable archive is not claimed. Published-1.3 upgrade qualification
+passed within its documented fixture scope; see [release status](../../../docs/RELEASE-STATUS.md).
+Read [MEMORY.md](../MEMORY.md) before interpreting evaluation results.
 
 ## Policies and migration
 
@@ -35,6 +37,20 @@ the packaged UPGRADING.md for failure recovery and legacy task handling.
 
 ## Intake, classification and modes
 
+Before initializing a fresh Unity task, map its known generated IDE/local metadata
+as exact `unityGeneratedFiles` paths in `.nccgs/inputs.json` (see
+[input freshness](task-gates.md#input-freshness-and-bounded-verification)). Preserve
+other input mappings and timeout ceilings. Inspect existing IDE files: custom or
+build-input files stay tracked. No automatic directory/glob ignore is applied.
+The manifest is pinned at init; generated-file hashes remain in verification
+receipts, while source, assets, packages and ProjectSettings remain in the source
+snapshot. Existing tasks retain their original inputs and historical verdicts.
+
+Large implementation tasks may use `task slice-preview|slice-plan --id TASK --file
+PLAN` and `task slice-status --id TASK`; see [task slices](task-slices.md).
+These commands preserve the original task and gates. A pinned plan tracks bounded
+delivery assignments, not replacement contracts or additional budgets.
+
 Example `.nccgs/evidence/intake/hud-fix.json`:
 
 ```json
@@ -123,7 +139,7 @@ Use the returned ID in the Agent prompt prefix `[NCCGS-DISPATCH:ID]`, select the
 specified role and task route, and include contract, inputs, ownership and acceptance.
 PreToolUse claims the slot with actual session/tool-use identity. SubagentStart binds
 an unambiguous agent ID. Foreground PostToolUse completion captures final telemetry.
-For this preview use foreground calls; background runs hold slots until correlated
+Use foreground calls; background runs hold slots until correlated
 final evidence or external reconciliation. SubagentStop alone cannot prove model,
 effort or complete usage. Ambiguous same-role starts are not guessed.
 
@@ -146,6 +162,9 @@ Audit/plan protect one review slot. Existing ledgers retain their pinned allocat
 At most two implementation workers can reserve disjoint paths; review/analysis
 cannot overlap source writers. Direct edit tools enforce ownership. Opaque shell/MCP
 operations are not OS-sandboxed by NCCGS; inspect their actual diff and test effects.
+Typed Unity repair requires exclusive project ownership, exact pinned Editor steps
+and a source-scope audit. An uncertain Editor operation retains that ownership
+even after the native worker returns; its observed usage and handoff remain recorded.
 Audit/plan/review block arbitrary shells and unknown tools. Use read tools, declared
 analysis artifacts and externally supplied command evidence when required.
 
@@ -189,6 +208,11 @@ With reviewContractRequired, the completed reviewer's pinned handoff must contai
 exactly one nccgs-review JSON block; copy its verdict, criteriaMet, findings and
 conditions exactly into the stage payload. Pending conditions block PASS. Follow
 [review handoff](review-handoff.md); a coordinator cannot remove those conditions.
+For source versions with handoff automation, the coordinator can instead use
+`task record-review --id TASK --dispatch ID --file PATH` to import those fields
+directly from the completed pinned handoff through the same record gate. The
+running worker can first use `task handoff-validate` on its own declared file to
+catch structure errors. See [handoff operations](../../../docs/HANDOFF-AUTOMATION.md).
 For design revisions, run fixed `task design-compare --id TASK --baseline PINNED_SOURCE
 --file DECLARED_CANDIDATE` before the final review and supply its immutable receipt.
 
@@ -258,7 +282,38 @@ Telemetry reports known subtotals and coverage for duration, tool calls, tokens
 cost. Total is null if any started attempt lacks that metric. Observed zero remains
 zero. These are worker measurements; coordinator work, human delay and billing are
 not automatically covered. A configured spend/time ceiling cannot interrupt an
-already running provider request and refuses new dispatch with unknown measurements.
+already running provider request. Unknown duration still blocks its optional cap.
+
+When worker cost is missing, `limits.maxCostUsd` can instead use a conservative
+supervised-session ceiling. `nccgs run --session-budget-usd` supplies the current
+whole-session allowance, including coordinator work. The guard adds verified
+terminal costs of every prior supervised session in the task ancestry and requires
+that total plus the current allowance fit the original cap. Every started worker
+must belong to those sessions; unknown/corrupt prior usage, expired deadlines,
+uncovered sessions or missing exclusive supervisor ownership block admission.
+Concurrent supervised sessions cannot reuse one project's remaining allowance.
+Each reservation records its budget basis and must launch in that same session.
+This does not backfill worker telemetry: preserve null cost, never allocate the
+session total to a worker or infer it from tokens. Without supervised coverage,
+the optional cost cap still requires complete worker measurements. Pinned limits
+cannot be unset through another reservation. `dispatch-reconcile` only settles
+active/uncertain slots; it does not backfill cost on a completed dispatch.
+
+For tasks with a pinned `budget-plan`, the root's protected final-review reserve
+also applies to every child. Work phases pay for design (including its review),
+implementation, checks and repair, leaving the reserved money and time intact.
+After recording implementation from the completed native worker and fresh checks,
+invoke `node .claude/nccgs/tools/task.mjs report --id TASK --outcome partial --summary "Awaiting protected independent review"`
+before ending the work session. A prose PARTIAL response alone does not write the
+lifecycle report. Do not dispatch the delivery reviewer inside the work phase.
+The external supervisor launches the same task with
+`--budget-phase final-review`. That phase may only dispatch independent delivery
+reviewers and settle existing evidence; it cannot fund repair or new checks.
+Read `task budget-status --id TASK` for the pinned terms and settled spend. A new
+session does not reset either allocation. Unknown in-flight cost remains unknown.
+If the final reviewer cannot finish, preserve PARTIAL; reserved funds are not a
+review verdict or permission to reduce acceptance. Only the external operator
+registers the plan before spending; a native worker/coordinator cannot edit it.
 
 Native capture follows the documented Claude Code [hook inputs and Agent tool
 response](https://code.claude.com/docs/en/hooks): resolvedModel/modelsUsed and native
@@ -269,5 +324,6 @@ Actual field availability and correlation must be confirmed by the real pilot.
 
 Framework tests and the synthetic five-size benchmark validate mechanics. They
 cannot measure model reasoning, game quality or end-to-end team productivity.
-Use [the pilot protocol](standalone-pilot.md) before stable promotion. CP0 remains
-reference-only; it is not a valid scored run for this purpose.
+The [historical pilot protocol](standalone-pilot.md) describes benchmark controls.
+Any qualification of this stable archive needs fresh scoped evidence; package
+preparation does not establish it. CP0 remains reference-only and cannot be scored.

package/.claude/nccgs/protocols/standalone.md

@@ -1,4 +1,4 @@
-# Standalone Claude Code execution — 2.0 RC
+# Standalone Claude Code execution — 2.0.0
 
 Read `.claude/nccgs/MEMORY.md`. NCCGS means New Claude Code Game Studio. Only
 real Claude Code execution supplies NCCGS orchestration evidence. Codex maintenance,
@@ -73,6 +73,12 @@ dependent work; independent inspection may proceed.
 
 ## Reserve, execute, verify, review
 
+When one implementation assignment is too broad, follow [task slices](task-slices.md).
+Preview and pin bounded assignments inside the same task and total budget. Preserve
+original criteria, reviewed rules and early checkpoints. Only final integration
+can supply whole-task implementation; intermediate handoffs are not acceptance.
+The independent reviewer must differ from all slice/repair contributors.
+
 The main Claude Code session coordinates. Reserve every worker before invoking
 Agent; do not delegate recursively. A reservation request contains a stable
 `requestKey`, `kind` (`implementation|analysis|review`), known `agent`, concrete
@@ -85,8 +91,12 @@ node .claude/nccgs/tools/task.mjs reserve --id TASK --request .nccgs/evidence/re
 
 Prefix the Agent prompt with `[NCCGS-DISPATCH:RETURNED_ID]`. Include the task's
 contract, route, owned paths, acceptance criteria and expected bounded handoff.
+Use `task dispatch-prompt --id TASK --dispatch RETURNED_ID` through the plain
+task CLI to generate that prompt and PARTIAL draft templates from the reservation.
+This prepares an assignment without launching it or authoring evidence. The
+worker writes its own handoff. See [handoff operations](../../../docs/HANDOFF-AUTOMATION.md).
 The pre-tool hook claims the reservation using the actual session/tool-use ID.
-Use foreground Agent calls for this preview. Launch distinct roles sequentially
+Use foreground Agent calls in 2.0.0. Launch distinct roles sequentially
 through their start hooks; ambiguous start identities must not be guessed.
 Background Agent/Task calls are rejected.
 `nccgs run` also sets `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` to prevent native
@@ -113,13 +123,16 @@ feedback; `purpose: "qa"` is a read-only QA/verification dispatch. Ordinary deli
 cannot consume the protected tail. Inspect `dispatch-status.deliveryBudget` and stop
 expansion before it runs out; more review rounds do not create more dispatch slots.
 
-Fresh repair reservations require a pinned `workPacket`, 1–4 exact existing source
-files and one fresh handoff path. Choose the correction before reserving; do not
+Fresh repair reservations require a pinned `workPacket`, exact file ownership
+and one fresh handoff path. Choose the correction before reserving; do not
 send an open-ended tuning investigation. `task dispatch-prompt --id TASK --dispatch ID`
 returns the bounded assignment; the launch hook injects the same prompt. Repair
-workers have at most 12 work tool calls (6 reads), 3 separate handoff writes and a
-10-minute tool-admission deadline. Shell/MCP/web/delegation are blocked for these
-workers. The coordinator runs declared checks after return. See
+schema-1 packets retain 1–4 existing files, 12 work calls (6 reads), 3 handoff writes
+and a 10-minute admission deadline. Opt-in schema-2 unity-code/unity-editor packets
+support exact new files or pinned Editor operations with profile-specific limits,
+GUID preservation and project-wide exclusive ownership. Only the fixed
+repair-editor wrapper may execute their pinned Unity CLI steps; general shell,
+MCP, web and delegation remain blocked. The coordinator runs declared checks after return. See
 [bounded repair](bounded-repair.md) for packet fields and limitations.
 These limits do not add native turns or reset dispatch quota.
 
@@ -130,16 +143,23 @@ and use `job-status` or bounded `job-wait`. Reuse its receipt for QA and closure
 do not rerun successful checks just to capture evidence. A helper's arguments after
 `--` belong to the helper, including its own `--project`. Audit/plan/review
 workers use read tools and declared analysis artifacts; arbitrary shell and unknown
-MCP tools are blocked. If a required analysis check needs command execution,
+MCP tools are blocked. A running non-repair worker may use only the fixed
+`task handoff-validate` command for its own declared handoff; it checks structure
+without executing arbitrary code or recording a stage. If a required analysis check needs command execution,
 provide externally run evidence or start a separately authorized implementation
 task. Do not loosen mode simply to bypass the guard.
 
 Record implementation/analysis with its completed `dispatchId`, current snapshot,
 checks, artifacts and captured runtime observation. Record independent review with
 a fresh completed review dispatch and explicit verdict/findings. The same dispatch
-cannot be consumed twice. Read `task inspect` and the task-gates schema documentation
-for exact payload fields in [standalone gates](standalone-gates.md). Missing observations block the relevant stage; never
-author runtime evidence to make it pass.
+cannot be consumed twice. Read `task inspect` and the exact payload fields in
+[standalone gates](standalone-gates.md). Missing observations block the relevant
+stage; never author runtime evidence to make it pass.
+
+For a completed reviewer-owned handoff, `task record-review --id TASK --dispatch ID
+--file PATH` imports the exact pinned result through the same record gate. It
+preserves negative verdicts, conditions, history and spent budgets. This command
+is coordinator-only; it does not report success or close the task.
 
 ## Report and stop
 
@@ -182,6 +202,6 @@ invent missing native usage or release uncertain provider dispatches. A supervis
 session may yield while that external owner waits; an unsupervised premature Stop
 receives a bounded reminder to collect pending jobs. DONE still rejects pending jobs.
 
-This preview is ready for a fresh Claude Code pilot after framework fixture tests.
-It is not a completed real-runtime benchmark. Contaminated Vector Survivors CP0
+A fresh full Unity qualification of the exact 2.0.0 archive remains separate from
+framework fixture tests and frozen earlier-version qualifications. Contaminated Vector Survivors CP0
 must not be scored or presented as an independent NCCGS implementation.

package/.claude/nccgs/protocols/task-gates.md

@@ -21,7 +21,9 @@ Run the installed tool as `node .claude/nccgs/tools/task.mjs COMMAND ...`, or us
 4. `task snapshot` prints the current source fingerprint. It covers files, names,
    additions, and deletions, including untracked files. Top-level generated roots
    in pipeline.json and explicit Build/Builds output subdirectories from
-   `.nccgs/inputs.json` are excluded. Requirements, decisions and registered canon
+   `.nccgs/inputs.json` are excluded. Opt-in exact `unityGeneratedFiles` paths are
+   also excluded from source, with their before/after hashes retained in managed
+   verification receipts. Requirements, decisions and registered canon
    are pinned separately and included in the snapshot. The plan and evidence files
    retain their own hashes. Never place source or canon in an excluded directory.
 5. `task ref --file .nccgs/evidence/check.log` prints a `{path, sha256}` reference.
@@ -120,6 +122,16 @@ YAML and Markdown links are not automatically followed. Do not register generate
 task/evidence folders as canonical inputs. Configure per-check `timeoutMs` and
 explicit build output subdirectories in the same manifest.
 
+For a new Unity project, declare only known, wholly generated IDE/local metadata
+files in `unityGeneratedFiles` before init. Use exact project-root `.csproj`,
+`.sln`/`.slnx` paths, `.vscode/extensions.json`, `.vscode/launch.json`,
+`.vscode/settings.json`, `UserSettings/EditorUserSettings.asset` or
+`UserSettings/Search.settings`, as applicable. No folders or globs are accepted.
+Do not declare user-owned IDE configuration or project files consumed as build
+inputs; leave them tracked or register them as canonical inputs. Canonical/output
+overlaps are rejected. This opt-in policy is itself pinned; adding exclusions
+after a FAIL cannot make that old attempt pass or preserve stale approvals.
+
 After an approved input change, or for a 1.4 task lacking input pins, run
 `task refresh-inputs --id ID --reason TEXT`. This archives the old state, clears
 stages, retains review consumption, and requires fresh observations/checks and