nccgs 2.0.0-rc.2 → 2.0.0

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

@@ -0,0 +1,106 @@
+# Bounded slices inside one task
+
+Standalone implementation only. Use this when one assignment is too broad for a
+worker's existing turn/context limit. Keep small tasks as one normal dispatch.
+The coordinator selects the decomposition; the CLI validates and tracks it.
+
+## Choose a useful boundary
+
+Start from the original acceptance criteria and reviewed requirements. Group a
+small, coherent behavior with its tests and exact files. Separate independent
+responsibilities; order shared files explicitly. Include Unity metadata files in
+the write set when import will create them. Do not divide by an arbitrary file
+count or invent new acceptance thresholds. If the original early checkpoint is
+required, put the work needed for it in the first slice and measure it before
+expanding. Slicing does not bypass that checkpoint.
+
+Use the fewest slices that fit bounded assignments: 2–12 slices, each with 1–8
+exact files. Dependencies form an acyclic graph. One final `integration` slice
+must transitively depend on every other slice; it can implement the last behavior
+while integrating, so a separate ceremonial integration dispatch is unnecessary.
+Each original criterion ID, including manual criteria, has exactly one primary
+slice owner. Ownership is responsibility, not local approval. Original checks,
+artifacts, design rules, risk/model route and manual/external gates still apply.
+
+## Preview and register
+
+Copy `.nccgs/templates/task-slices.json` to a draft under
+`.nccgs/evidence/slice-plans/`. Fill in the existing task ID, current contract hash
+and source snapshot, a unique plan ID, reason, slice scopes and criterion IDs.
+Use `task inspect` and `task snapshot` to obtain current values. A first plan has
+`supersedes: null`; a revision names the current plan ID. No budget or replacement
+contract fields are accepted.
+
+```text
+node .claude/nccgs/tools/task.mjs slice-preview --id TASK --file .nccgs/evidence/slice-plans/TASK.json
+node .claude/nccgs/tools/task.mjs slice-plan --id TASK --file .nccgs/evidence/slice-plans/TASK.json
+node .claude/nccgs/tools/task.mjs slice-status --id TASK
+```
+
+Preview is read-only. Registration captures an immutable plan under
+`.nccgs/evidence/slices/` and appends a ledger event. It does not rewrite the task,
+record implementation, spend a dispatch or start a provider invocation. Existing
+limits and ancestor relationships are preserved. If dispatch limits have not yet
+been pinned, registration pins the ordinary task defaults. Use the existing
+reservation workflow to establish any intended custom limits before registration.
+
+Capacity accounts for already spent attempts, all pending slices in the ancestor
+subtree, the original protected repair/QA/review reserve and required independent
+review still ahead. It rejects a plan or later dispatch that cannot fit. It is a
+dispatch lower bound, not an estimate of cost, time, retries or semantic completeness.
+Existing observed cost/duration admission and `nccgs run` session budgets remain
+in force. Missing usage stays unknown. No child task, review round, native turn
+allowance, new session budget or refund is created by splitting.
+
+## Execute and integrate
+
+`slice-status.next` contains the next eligible reservation request, with the exact
+agent, files, `sliceId`, fresh handoff path and stable request key. Save that object
+under `.nccgs/evidence/requests/`, reserve it normally, then use `dispatch-prompt`
+and the existing foreground Agent/handoff workflow. This is preparation, not an
+automatic launch. Finish one slice before starting the next. A dependency must
+have a complete pinned native handoff with valid model evidence. The dependent
+dispatch pins its exact predecessor dispatch IDs.
+
+The launch hook adds the pinned objective, original criterion definitions,
+relevant reviewed requirements and global constraints. It keeps the same task and
+model route. Integration receives the full original acceptance list. Structured
+source writes are restricted to exact planned files; existing shell/MCP policy
+still applies. These controls do not provide an operating-system sandbox.
+
+Status `DELIVERED` means native completion plus a complete intact handoff. It is
+not acceptance PASS. Do not record intermediate slices as implementation stages.
+After all slices are delivered, run the original applicable checks against the
+current integrated source and record the final integration dispatch. A subsequent
+bounded repair follows the existing repair workflow and can supply the replacement
+implementation stage; it must still pass the whole task's gates.
+
+The independent reviewer evaluates the full integrated contract and must differ
+from every implementation contributor in the task subtree, including earlier
+slices and failed repairs. Reviewer-owned negative findings/conditions, review
+limits, objective measurements and manual/external acceptance remain unchanged.
+No per-slice review ceremony replaces or adds to the required whole-task review.
+
+## Partial work and revisions
+
+Keep failed/PARTIAL attempts and their handoffs. Retry only with an eligible fresh
+reservation and handoff inside the same remaining budget. Fix malformed/tampered
+evidence through the existing recovery process; never edit captured history.
+
+Settle active reservations before revising. Use a new plan ID, current source
+snapshot, explicit reason and `supersedes` pointing at the active plan. For the same
+contract, retain the IDs of all attempted slices. Their definitions may be refined
+explicitly, but changed slices and affected dependents become stale and require
+fresh delivery. Unchanged work can carry forward only when its latest attempt,
+definition, contract and exact dependency dispatches remain valid. Retrying an
+upstream slice also invalidates downstream delivery even if its source looks similar.
+
+Plan versions, reasons, reservations and lifecycle history remain available. Replaying
+an old plan is idempotent and cannot reactivate it. A plan cannot refresh a contract
+or authorize new product scope; use the original explicit contract workflow for
+that, retaining history and spent budgets. If the remaining budget cannot fit the
+work, report partial/blocked with unresolved criteria. Do not create replacement
+tasks, reduce criteria or increase limits to make the plan pass.
+
+This feature is included in the prepared, unpublished 2.0.0 stable package. Synthetic framework tests do not
+establish fresh Claude Code or Unity execution, cost savings or game quality.

package/.claude/nccgs/routing.generated.md

@@ -27,3 +27,23 @@ Existing installations without execution.json retain compatibility execution: As
 Legacy independent review: fable/high. Updating never converts historical approval into a current approval. Explicit migration preserves tasks and consumed budgets.
 
 Default active agents: 13. Full library: 47.
+
+## Configured native turn ceilings
+
+Generated from agent-library frontmatter by compile-policy.mjs. These are ceilings, not targets or observed session settings. Verify the installed role and any native session override before dispatch; prompt text cannot increase maxTurns.
+
+| Default active role | maxTurns |
+|---|---:|
+| nccgs-fast-implementer | 12 |
+| nccgs-task-scout | 10 |
+| nccgs-game-designer | 48 |
+| nccgs-gameplay-programmer | 120 |
+| nccgs-engine-programmer | 22 |
+| nccgs-ui-programmer | 22 |
+| nccgs-qa-engineer | 22 |
+| nccgs-verification-engineer | 22 |
+| nccgs-adversarial-reviewer | 200 |
+| nccgs-unity-implementer | 120 |
+| nccgs-unity-systems-specialist | 22 |
+| nccgs-unity-ui-specialist | 22 |
+| nccgs-unity-build-specialist | 24 |

package/.claude/nccgs/tools/command-process.mjs

@@ -7,8 +7,9 @@ import { spawn, spawnSync } from "node:child_process";
 import { atomicJson } from "./policy.mjs";
 
 const windowsSource = fileURLToPath(new URL("./windows-job.cs", import.meta.url));
+const compilerShutdownSource = fileURLToPath(new URL("./windows-compiler-server.cs", import.meta.url));
 function windowsHost() {
-  const digest = crypto.createHash("sha256").update(fs.readFileSync(windowsSource)).digest("hex");
+  const digest = crypto.createHash("sha256").update(fs.readFileSync(windowsSource)).update(fs.readFileSync(compilerShutdownSource)).digest("hex");
   // Build the bundled, inspectable helper; no system execution policy changes.
   const directory = path.join(os.tmpdir(), "nccgs-native", digest);
   fs.mkdirSync(directory, { recursive: true });
@@ -16,22 +17,27 @@ function windowsHost() {
   if (fs.existsSync(binary)) return binary;
   const compiler = path.join(process.env.SystemRoot || "C:/Windows", "Microsoft.NET/Framework64/v4.0.30319/csc.exe");
   const temporary = path.join(directory, `${crypto.randomUUID()}.exe`);
-  const result = spawnSync(compiler, ["/nologo", "/target:exe", "/reference:System.Web.Extensions.dll", `/out:${temporary}`, windowsSource], { encoding: "utf8", windowsHide: true, timeout: 30000 });
+  const result = spawnSync(compiler, ["/nologo", "/target:exe", "/reference:System.Web.Extensions.dll", `/out:${temporary}`, windowsSource, compilerShutdownSource], { encoding: "utf8", windowsHide: true, timeout: 30000 });
   if (result.status !== 0 || result.error) throw new Error(`Cannot compile Windows process-group helper: ${result.error?.message || result.stdout || result.stderr}`);
   try { fs.renameSync(temporary, binary); }
   catch (error) { if (!fs.existsSync(binary)) throw error; fs.unlinkSync(temporary); }
   return binary;
 }
 export function startCommand({ executable, args, cwd, stateDirectory, id, stdio }) {
+  // Unity CLI's on-demand auth broker outlives a short test by two idle minutes.
+  // Keep every descendant owned; use the CLI's supported direct OS-keyring path
+  // for this command tree instead of spawning a resident broker. Wrappers inherit
+  // the flag too. Do not change global settings, peer checks or the parent's env.
+  const env = { ...process.env, UNITY_NO_AUTH_BROKER: "1" };
   if (process.platform !== "win32") {
-    const child = spawn(executable, args, { cwd, detached: true, shell: false, windowsHide: true, stdio });
+    const child = spawn(executable, args, { cwd, detached: true, shell: false, windowsHide: true, stdio, env });
     return { child, identity: () => ({ pid: child.pid, group: true }) };
   }
   const groupName = `Local\\NCCGS-${id}`;
   const spec = path.join(stateDirectory, `${id}-command.json`);
   atomicJson(spec, { executable, arguments: args, cwd, groupName });
   const child = spawn(windowsHost(), ["run", spec],
-    { cwd, shell: false, windowsHide: true, stdio });
+    { cwd, shell: false, windowsHide: true, stdio, env });
   return { child, identity: () => ({ pid: child.pid, groupName, windowsJob: true }) };
 }
 export function windowsGroupState(groupName) {

package/.claude/nccgs/tools/compile-policy.mjs

@@ -83,6 +83,10 @@ export function generated(project) {
     return `| ${risk} | ${route.model} | ${route.effort} |`;
   }).join("\n");
   outputs.set(".claude/nccgs/routing.generated.md", `# Generated routing — edit pipeline.json, then compile-policy.mjs\n\nNCCGS runs in Claude Code. New installations use standalone execution; model aliases describe requested routes, not observed provider versions. Model selection in project.yaml and execution obligations in execution.json are separate policies.\n\n| Stage | Owner/model | Effort | Maximum review rounds |\n|---|---|---|---|\n| Intake, plan and documents | Claude Code | Routed by task | — |\n${tierRows}\n| Independent review | ${standaloneProfile.models.review.model} | ${standaloneProfile.models.review.effort} | Shared task budget |\n| External review | Off by default; advisory or required when configured | External evidence | — |\n| Acceptance | Contract-defined Product Owner decision | Explicit when required | — |\n\nFAST: nccgs-fast-implementer. STANDARD: the relevant domain programmer. CONTROLLED: nccgs-unity-implementer with the affected specialists. Use nccgs-task-scout only for a bounded missing fact; it does not replace review.\n\nA task-wide review budget survives implementation retries and continuation. Exhaustion stops the loop; a reasoned extension is required. Report is available for blocked/partial work and is not approval. Missing runtime effort remains unknown unless supplied by observed evidence.\n\nExisting installations without execution.json retain compatibility execution: Astra plan/document ownership, required external check and Product Owner acceptance. Legacy astra-claude routes remain unchanged:\n\n| Risk | Model | Effort |\n|---|---|---|\n${legacyRows}\n\nLegacy independent review: ${contractProfile.models.review.model}/${contractProfile.models.review.effort}. Updating never converts historical approval into a current approval. Explicit migration preserves tasks and consumed budgets.\n\nDefault active agents: ${activeCount}. Full library: ${studio.agents.length}.\n`);
+  const nativeRows = studio.agents.filter(agent => primary.activeAgents === "all" || primary.activeAgents.includes(agent.name))
+    .map(agent => `| ${agent.name} | ${agent.maxTurns ?? "Unspecified"} |`).join("\n");
+  const routingPath = ".claude/nccgs/routing.generated.md";
+  outputs.set(routingPath, outputs.get(routingPath) + `\n## Configured native turn ceilings\n\nGenerated from agent-library frontmatter by compile-policy.mjs. These are ceilings, not targets or observed session settings. Verify the installed role and any native session override before dispatch; prompt text cannot increase maxTurns.\n\n| Default active role | maxTurns |\n|---|---:|\n${nativeRows}\n`);
   const scaffold = path.join(project, "scaffold/.nccgs/project.yaml");
   if (fs.existsSync(scaffold)) {
     const text = fs.readFileSync(scaffold, "utf8");

package/.claude/nccgs/tools/editor-session-evidence.mjs

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const need = (ok, message) => { if (!ok) throw new Error(`Editor session evidence: ${message}`); };
+const hash = bytes => crypto.createHash("sha256").update(bytes).digest("hex");
+const samePath = (a, b) => path.resolve(a) === path.resolve(b);
+const identity = value => value?.windowsJob === true && Number.isSafeInteger(value.pid) && value.pid > 0 && /^Local\\NCCGS-[a-f0-9-]{36}$/.test(value.groupName ?? "");
+
+// Copy existing operator receipts for the reviewer. Never execute a command,
+// stop a process, rewrite a task/review, or manufacture a new runtime observation.
+// This is evidence publication, not acceptance or independent verification.
+export function publishEditorSessionEvidence(project, { sourceProject, startFile, stopFile, shutdownFile, id = crypto.randomUUID() }) {
+  need(typeof sourceProject === "string" && path.isAbsolute(sourceProject), "sourceProject must be explicit and absolute");
+  need(/^[a-f0-9-]{36}$/.test(id), "invalid bundle id");
+  project = fs.realpathSync(project);
+  const originals = { start: startFile, stop: stopFile, shutdown: shutdownFile };
+  const data = {}, bytes = {};
+  for (const [kind, file] of Object.entries(originals)) {
+    need(typeof file === "string" && path.isAbsolute(file), `${kind} path must be absolute`);
+    const stat = fs.lstatSync(file);
+    need(stat.isFile() && !stat.isSymbolicLink() && stat.size <= 1024 * 1024, `${kind} must be a bounded regular receipt`);
+    bytes[kind] = fs.readFileSync(file);
+    try { data[kind] = JSON.parse(bytes[kind].toString("utf8")); } catch { need(false, `${kind} is not JSON`); }
+  }
+  const { start, stop, shutdown } = data;
+  need(identity(start.identity) && identity(stop.identity), "owned Windows Editor identities required");
+  need(start.identity.pid === stop.identity.pid && start.identity.groupName === stop.identity.groupName, "start/stop ownership mismatch");
+  need(typeof start.project === "string" && samePath(start.project, sourceProject), "start project mismatch");
+  need(stop.state === "dead" && stop.forced === false && stop.result?.code === 0 && stop.result?.signal === null, "normal settled Editor exit required; retain failed/uncertain evidence separately");
+  const args = shutdown.args;
+  need(Array.isArray(args) && args.every(v => typeof v === "string"), "shutdown arguments required");
+  need(args[0] === "command" && ["eval", "script"].includes(args[1]), "expected recorded Unity command");
+  need(args.filter(v => v === "--project-path").length === 1 && samePath(args[args.indexOf("--project-path") + 1] ?? "", sourceProject), "shutdown project mismatch");
+  need(args.some(v => /UnityEditor\.EditorApplication\.Exit\(0\)/.test(v)), "recorded graceful Editor exit is missing");
+  need(identity(shutdown.identity) && shutdown.treeState === "dead", "shutdown CLI ownership must be settled");
+  need(shutdown.code === 0 && shutdown.signal === null, "shutdown CLI did not complete normally");
+  need(Number.isFinite(Date.parse(start.at)) && Number.isFinite(Date.parse(shutdown.at)) && Date.parse(shutdown.at) >= Date.parse(start.at), "invalid event ordering");
+
+  // No junction/symlink in the output chain, even when importing into an addendum.
+  const relative = `.nccgs/evidence/editor-control/operator-${id}`;
+  let directory = project;
+  for (const segment of [".nccgs", "evidence", "editor-control"]) {
+    directory = path.join(directory, segment);
+    if (fs.existsSync(directory)) need(fs.lstatSync(directory).isDirectory() && !fs.lstatSync(directory).isSymbolicLink() && fs.realpathSync(directory) === directory, "output path redirects outside the project");
+    else fs.mkdirSync(directory);
+  }
+  directory = path.join(project, relative);
+  fs.mkdirSync(directory); // exclusive directory creation: never replace a prior bundle
+  const references = {};
+  for (const kind of Object.keys(originals)) {
+    const name = `${kind}.json`;
+    fs.writeFileSync(path.join(directory, name), bytes[kind], { flag: "wx" });
+    references[kind] = { path: `${relative}/${name}`, sha256: hash(bytes[kind]) };
+  }
+  const receipt = {
+    schemaVersion: 1, origin: "external-operator-editor-evidence", recordedAt: new Date().toISOString(),
+    sourceProject, evidenceProject: project, historicalImport: !samePath(sourceProject, project),
+    editorIdentity: start.identity, reportedProcessState: stop.state, forced: stop.forced,
+    references, currentProcessProbe: "not performed by this publisher",
+    note: "Byte-preserved operator receipts only. Not native worker execution, acceptance, a reviewer verdict, or a new Editor stop. Original event times and ownership remain in the referenced files."
+  };
+  const manifest = Buffer.from(JSON.stringify(receipt, null, 2) + "\n");
+  fs.writeFileSync(path.join(directory, "receipt.json"), manifest, { flag: "wx" });
+  return { path: `${relative}/receipt.json`, sha256: hash(manifest) };
+}

package/.claude/nccgs/tools/gates.mjs

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
 import { hash, json, contained, artifact, verifyArtifact, atomicJson, loadPipeline, resolveExecution } from "./policy.mjs";
-import { canonicalInputs, pinInputs, inputPolicy, isOutput } from "./inputs.mjs";
+import { canonicalInputs, pinInputs, inputPolicy, isOutput, isUnityGenerated, unityGeneratedState } from "./inputs.mjs";
 import { migrateTaskEvidence } from "./evidence.mjs";
 import { acquireLock } from "./process-lock.mjs";
 import { initializeStandalone, checkStandalone, recordStandalone, extendStandalone, refreshStandalone,
@@ -14,7 +14,7 @@ export function taskPath(project, id) {
   requireValue(typeof id === "string" && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/.test(id), "Invalid task ID");
   return contained(project, `.nccgs/tasks/${id}.json`);
 }
-export function snapshot(project, task = null) {
+export function snapshot(project, task = null, { includeFiles = false } = {}) {
   const started = performance.now();
   const excluded = new Set(loadPipeline(project).snapshotExcludes);
   const policy = inputPolicy(project);
@@ -26,7 +26,7 @@ export function snapshot(project, task = null) {
       if (!relative && excluded.has(entry.name)) continue;
       const name = relative ? `${relative}/${entry.name}` : entry.name;
       const file = contained(project, name);
-      if (isOutput(name, policy)) continue;
+      if (isOutput(name, policy) || isUnityGenerated(name, policy)) continue;
       if (entry.isDirectory()) walk(name);
       else if (entry.isFile()) {
         const readStarted = performance.now();
@@ -39,10 +39,13 @@ export function snapshot(project, task = null) {
     }
   }
   walk();
+  const generatedFiles = unityGeneratedState(project, policy);
   files.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
   return { sha256: hash(JSON.stringify({ files, canonicalInputs: inputs.sha256 })), sourceSha256: hash(JSON.stringify(files)), files: files.length,
     bytes, canonicalInputSha256: inputs.sha256, canonicalInputFiles: inputs.entries.filter(e => e.kind === "file").length,
-    canonicalInputBytes: inputs.bytes, readHashMs: readHashMs + inputs.readHashMs, durationMs: performance.now() - started };
+    canonicalInputBytes: inputs.bytes, readHashMs: readHashMs + inputs.readHashMs, durationMs: performance.now() - started,
+    ...(includeFiles ? { fileEntries: files } : {}),
+    ...(generatedFiles.length ? { unityGeneratedFiles: generatedFiles } : {}) };
 }
 function tierRoute(pipeline, risk) {
   const tier = pipeline.contract.taskTiers?.[risk];

package/.claude/nccgs/tools/handoff.mjs

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import { artifact, json, verifyArtifact } from "./policy.mjs";
+import { check, record, taskPath } from "./gates.mjs";
+import { getDispatch } from "./orchestration.mjs";
+import { readReviewHandoff, validateReviewStructure } from "./review-handoff.mjs";
+
+const need = (ok, message) => { if (!ok) throw new Error(`Handoff: ${message}`); };
+
+function context(project, id, dispatchId, relative) {
+  const task = json(taskPath(project, id)), dispatch = getDispatch(project, id, dispatchId);
+  need(dispatch.contractHash === task.contractHash, "dispatch contract is stale");
+  need(dispatch.handoffPaths?.includes(relative), "file must be this dispatch's declared handoff");
+  need(["running", "completed"].includes(dispatch.status), "handoff inspection requires a running or completed dispatch");
+  const state = check(project, task, task.mode === "implement" ? "implementation" : "analysis");
+  need(state.allowed, state.message);
+  const expected = dispatch.status === "completed" ? dispatch.completedSnapshot : dispatch.kind === "implementation" ? state.snapshot : dispatch.snapshot;
+  need(state.snapshot === expected, "source snapshot is stale");
+  // A completed handoff is always read through its captured reference. A new hash
+  // cannot legitimize edits made after completion.
+  const evidence = dispatch.status === "completed"
+    ? dispatch.handoff?.artifacts?.find(ref => ref.path === relative) : artifact(project, relative);
+  need(evidence, "completed dispatch did not pin this handoff");
+  const content = fs.readFileSync(verifyArtifact(project, evidence), "utf8");
+  return { task, dispatch, snapshot: state.snapshot, evidence, content };
+}
+
+export function validateHandoff(project, id, dispatchId, relative) {
+  const ctx = context(project, id, dispatchId, relative);
+  const markers = [...ctx.content.matchAll(/^NCCGS-HANDOFF: (PARTIAL|COMPLETE)\r?$/gm)];
+  need(markers.length === 1, "exactly one PARTIAL or COMPLETE marker is required");
+  const complete = markers[0][1] === "COMPLETE";
+  if (ctx.dispatch.kind === "review") {
+    const { value } = readReviewHandoff(ctx.content, ctx.task, ctx.snapshot, false);
+    validateReviewStructure(value, ctx.task);
+  }
+  verifyArtifact(project, ctx.evidence);
+  return { status: "VALID", taskId: id, dispatchId, evidence: ctx.evidence, complete,
+    scope: "Structure only; not native completion, semantic review, verification or acceptance. No task, budget or handoff was changed." };
+}
+
+export function recordReviewHandoff(project, id, dispatchId, relative) {
+  const ctx = context(project, id, dispatchId, relative);
+  need(ctx.dispatch.kind === "review" && ctx.dispatch.status === "completed", "a completed independent review dispatch is required");
+  need(ctx.task.execution.reviewContractRequired === true, "automatic import requires the reviewer-owned contract policy; legacy records retain their workflow");
+  const { value } = readReviewHandoff(ctx.content, ctx.task, ctx.snapshot);
+  // No caller-supplied verdict, findings, conditions, runtime or snapshot. The
+  // existing record path checks independence, telemetry, criteria and budgets,
+  // appends history, and rejects reusing a dispatch. It never closes the task.
+  return record(project, id, "review", { snapshot: ctx.snapshot, dispatchId, runtime: ctx.dispatch.runtime, evidence: ctx.evidence,
+    verdict: value.verdict, criteriaMet: value.criteriaMet, findings: value.findings, conditions: value.conditions });
+}

package/.claude/nccgs/tools/inputs.mjs

@@ -8,7 +8,32 @@ export function inputPolicy(project) {
   const policy = fs.existsSync(file) ? json(file) : { schemaVersion: 1, canonicalInputs: [], outputDirectories: [], checks: {} };
   if (policy.schemaVersion !== 1 || !Array.isArray(policy.canonicalInputs) || !Array.isArray(policy.outputDirectories)
       || !policy.checks || typeof policy.checks !== "object" || Array.isArray(policy.checks)) throw new Error("Invalid .nccgs/inputs.json schema");
-  for (const key of Object.keys(policy)) if (!["schemaVersion", "canonicalInputs", "outputDirectories", "checks"].includes(key)) throw new Error(`Unknown input manifest field: ${key}`);
+  for (const key of Object.keys(policy)) if (!["schemaVersion", "canonicalInputs", "outputDirectories", "checks", "unityGeneratedFiles"].includes(key)) throw new Error(`Unknown input manifest field: ${key}`);
+  const generated = policy.unityGeneratedFiles === undefined ? [] : policy.unityGeneratedFiles;
+  if (!Array.isArray(generated) || generated.length > 256) throw new Error("unityGeneratedFiles must be an array of at most 256 exact file paths");
+  const seenGenerated = new Set();
+  for (const relative of generated) {
+    const file = contained(project, relative);
+    // Opt-in derived metadata only. Never ignore whole directories, wildcards,
+    // nested tool projects, source, assets, packages or project settings.
+    if (!/^[^/]+\.(?:csproj|sln|slnx)$/.test(relative)
+        && !/^\.vscode\/(?:extensions|launch|settings)\.json$/.test(relative)
+        && !/^UserSettings\/(?:EditorUserSettings\.asset|Search\.settings)$/.test(relative)) {
+      throw new Error(`Unsupported Unity generated file: ${relative}`);
+    }
+    const key = relative.toLowerCase();
+    if (seenGenerated.has(key)) throw new Error(`Duplicate Unity generated file: ${relative}`);
+    seenGenerated.add(key);
+    if (fs.existsSync(file) && !fs.statSync(file).isFile()) throw new Error(`Unity generated path is not a file: ${relative}`);
+    for (const input of policy.canonicalInputs) if (overlaps(input, relative)) throw new Error(`Canonical input/generated file overlap: ${input} and ${relative}`);
+  }
+  if (generated.length) {
+    const version = contained(project, "ProjectSettings/ProjectVersion.txt");
+    if (!fs.existsSync(version) || !/^m_EditorVersion: \d+\.\d+\.\d+[abfp]\d+\s*$/m.test(fs.readFileSync(version, "utf8"))
+        || !fs.existsSync(contained(project, "Packages/manifest.json")) || !fs.statSync(contained(project, "Assets")).isDirectory()) {
+      throw new Error("unityGeneratedFiles requires a Unity project (Assets, Packages/manifest.json, ProjectSettings/ProjectVersion.txt)");
+    }
+  }
   for (const relative of [...policy.canonicalInputs, ...policy.outputDirectories]) contained(project, relative);
   for (const relative of policy.outputDirectories) {
     // Keep source roots in the snapshot. Unity build destinations must be deliberately
@@ -36,6 +61,16 @@ export function isOutput(relative, policy) {
   const normalize = name => process.platform === "win32" ? name.toLowerCase() : name;
   return policy.outputDirectories.some(dir => normalize(relative) === normalize(dir) || normalize(relative).startsWith(`${normalize(dir)}/`));
 }
+export function isUnityGenerated(relative, policy) {
+  const normalize = name => process.platform === "win32" ? name.toLowerCase() : name;
+  return (policy.unityGeneratedFiles ?? []).some(file => normalize(relative) === normalize(file));
+}
+export function unityGeneratedState(project, policy) {
+  return (policy.unityGeneratedFiles ?? []).map(relative => {
+    const file = contained(project, relative);
+    return { path: relative, sha256: fs.existsSync(file) ? hash(fs.readFileSync(file)) : null };
+  }).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
 export function canonicalInputs(project, policy = inputPolicy(project)) {
   const entries = new Map();
   let bytes = 0, readHashMs = 0;

package/.claude/nccgs/tools/lifecycle.mjs

@@ -229,6 +229,7 @@ function verification(project, task, input, spec, snap) {
     const file = verifyArtifact(project, check.evidence);
     if (check.evidence.path.endsWith(".json")) {
       const data = json(file);
+      assert(data.origin !== "unity-repair-operation", "Unity repair operation receipts are not verification evidence; run the original declared checks");
       if (data.origin === "verification-command") {
         assert(data.taskId === task.id && data.name === check.name && data.snapshot === snap && data.contractHash === task.contractHash && data.status === "PASS" && data.exitCode === 0 && data.sourceUnchanged === true, "Verification execution failed or stale");
         assert(Date.parse(data.startedAt) >= Date.parse(task.canonicalInputs.pinnedAt), "Verification predates current input pin");
@@ -474,6 +475,26 @@ export function refreshStandalone(project, task, reason) {
   // Do not reset audit/plan source baseline or any spent/allocated budget.
   return writeTask(project, task);
 }
+export function migrateFrameworkBaseline(project, id, relative) {
+  externalOnly();
+  const task = json(taskPath(project, id)), reference = artifact(project, relative), decision = json(verifyArtifact(project, reference));
+  assert(task.schemaVersion === 2 && task.mode !== "implement" && !task.closed, "Framework migration requires an open plan/audit task");
+  assert(nonempty(decision.reason) && nonempty(decision.authority) && Array.isArray(decision.beforeFiles), "Framework migration requires explicit external authority and original file inventory");
+  assert(digest(decision.beforeFiles) === task.analysisBaseline, "Original inventory does not match the pinned analysis baseline");
+  assert(task.executionHash === digest(resolveExecution(project)) && task.pipelineHash === digest(loadPipeline(project)), "Framework migration cannot change execution/pipeline policy");
+  assert(task.canonicalInputs.sha256 === canonicalInputs(project).sha256, "Framework migration cannot change canonical inputs");
+  assert(!dispatchStatus(project, id).active.length && !pendingJobs(project).length, "Settle all workers and verification before framework migration");
+  validateBudget(task);
+  const captured = snapshot(project, task, { includeFiles: true }), before = new Map(decision.beforeFiles), after = new Map(captured.fileEntries);
+  const changes = [...new Set([...before.keys(), ...after.keys()])].filter(file => before.get(file) !== after.get(file)).map(file => ({ path: file, before: before.get(file) ?? null, after: after.get(file) ?? null }));
+  assert(changes.length > 0 && changes.every(change => change.path.startsWith(".claude/")), "Framework migration refuses non-framework source changes");
+  invalidate(task, "migrate-framework-baseline");
+  Object.assign(task.history.at(-1), { reference, reason: decision.reason, authority: decision.authority,
+    previousBaseline: task.analysisBaseline, newBaseline: captured.sourceSha256, changes });
+  task.analysisBaseline = captured.sourceSha256; task.phase = "READY"; task.outcome = null;
+  // No evidence is promoted: fresh native analysis and independent review required.
+  return writeTask(project, task);
+}
 export function exportExternalStandalone(project, task, relative) {
   assert(task.execution.externalReview.mode !== "off", "External review is off for this task");
   const context = current(project, task);