nccgs 1.3.0 → 2.0.0-rc.2

package/.claude/nccgs/hooks/closure-guard.mjs

@@ -1,30 +1,53 @@
 import fs from "node:fs";
 import path from "node:path";
-import { readInput } from "./common.mjs";
-import { profilePolicy, json } from "../tools/policy.mjs";
+import { readInput, projectRoot } from "./common.mjs";
+import { profilePolicy, json, resolveExecution } from "../tools/policy.mjs";
 import { check, taskPath } from "../tools/gates.mjs";
 import { boundTask } from "../tools/runtime.mjs";
+import { guardTool, recoveryTool } from "../tools/tool-guard.mjs";
+import { pendingJobs } from "../tools/verification-jobs.mjs";
 
 const input = await readInput();
-const project = process.cwd();
+const project = projectRoot();
 try {
-  if (profilePolicy(project).name !== "astra-claude") process.exit(0);
+  if (process.argv[2] === "pre" && recoveryTool(input, project)) process.exit(0);
+  const policy = profilePolicy(project);
+  const execution = resolveExecution(project);
+  if (execution.name !== "standalone" && policy.name !== "astra-claude") process.exit(0);
   const mode = process.argv[2];
+  if (mode === "stop" && !process.env.NCCGS_SUPERVISED_SESSION) {
+    const taskId = boundTask(project, input.session_id);
+    const jobs = taskId ? pendingJobs(project, taskId) : [];
+    if (jobs.length) throw new Error(`Verification still pending: ${jobs.map(j => `${j.jobId}:${j.status}`).join(", ")}. Use task job-wait --id ${taskId} --job ID; retain the checkpoint if a process is unverified`);
+  }
   const tool = input.tool_input ?? {};
-  const absolute = path.resolve(tool.file_path || tool.path || project);
+  const guardOutput = mode === "pre" && execution.name === "standalone" ? guardTool(project, input) : null;
+  if (mode === "pre" && execution.name !== "standalone" && tool.subagent_type === policy.pipeline.contract.reviewAgent) {
+    const id = boundTask(project, input.session_id);
+    if (id) {
+      const readiness = check(project, json(taskPath(project, id)), "review");
+      if (!readiness.allowed) throw new Error(readiness.message);
+    }
+  }
+  const absolute = path.resolve(project, tool.file_path || tool.path || ".");
   const relative = path.relative(project, absolute).split(path.sep).join("/");
   const text = tool.content ?? tool.new_string ?? "";
-  if (mode === "pre" && /^\.nccgs\/(tasks|approvals)\//.test(relative)) throw new Error("Use the task gate CLI for task records. Astra/PO sign-offs must be imported outside Claude; never write them on their behalf.");
+  if (mode === "pre" && ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(input.tool_name) && /^\.nccgs\/(tasks|approvals)\//i.test(relative)) throw new Error("Use the task gate CLI for task records. Astra/PO sign-offs must be imported outside Claude; never write them on their behalf.");
   const shell = tool.command ?? "";
+  if (mode === "pre" && /\b(?:task(?:\.mjs)?|nccgs\s+task)\s+[\s\S]*?\bextend-review\b/i.test(shell)) throw new Error("Review budget extensions require an explicit external decision; Claude cannot extend its own review loop.");
   if (mode === "pre" && /(?:--stage\s+["']?(?:astra|acceptance)\b|\.nccgs[\\/]approvals[\\/])/i.test(shell)) throw new Error("Claude cannot create/import Astra or Product Owner sign-offs.");
   const completion = /(?:^|\n)\s*(?:[-*]\s*)?(?:\*\*)?(?:Final state|Status|State|Trạng thái)(?:\*\*)?\s*:\s*(?:\*\*)?DONE\b|^\s*(?:\*\*)?DONE\b|"(?:state|status)"\s*:\s*"DONE"/im;
   const claimsDone = mode === "stop"
     ? completion.test(input.last_assistant_message ?? "")
     : /^\.nccgs\/(?:closures\/|state\.md$)/.test(relative) && completion.test(text);
-  if (!claimsDone) process.exit(0);
+  if (!claimsDone) {
+    if (guardOutput) console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", ...guardOutput } }));
+    process.exit(0);
+  }
   const id = boundTask(project, input.session_id);
   if (!id) throw new Error("A DONE claim needs a session bound to an NCCGS task");
-  check(project, json(taskPath(project, id)), "done");
+  const readiness = check(project, json(taskPath(project, id)), "done");
+  if (!readiness.allowed) throw new Error(readiness.message);
 } catch (error) {
   if (process.argv[2] === "stop") {
     // Do not trap the session in an endless Stop-hook loop; the canonical close

package/.claude/nccgs/hooks/common.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
+import { hookProjectRoot } from "../tools/autonomy.mjs";
 
 export async function readInput() {
   let text = "";
@@ -10,7 +11,7 @@ export async function readInput() {
 }
 
 export function projectRoot() {
-  return process.cwd();
+  return hookProjectRoot();
 }
 
 export function readText(relative, limit = 12000) {

package/.claude/nccgs/hooks/runtime-observation.mjs

@@ -1,8 +1,8 @@
-import { readInput, appendRuntime } from "./common.mjs";
+import { readInput, appendRuntime, projectRoot } from "./common.mjs";
 import { observe } from "../tools/runtime.mjs";
 try {
   const input = await readInput();
-  const result = observe(process.cwd(), input, "agent_result");
+  const result = observe(projectRoot(), input, process.argv[2] === "failure" ? "agent_failure" : "agent_result");
   appendRuntime({ event: "runtime_observation", path: result.path, sessionId: result.sessionId, agentId: result.agentId, missing: result.missing });
   console.log(`NCCGS runtime evidence: ${result.path}; missing observation: ${result.missing.join(", ") || "none"}. Configuration is not runtime proof.`);
 } catch (error) {

package/.claude/nccgs/hooks/session-start.mjs

@@ -1,5 +1,6 @@
-import { git, readText, yamlValue, readInput } from "./common.mjs";
-import { profilePolicy } from "../tools/policy.mjs";
+import { git, readText, yamlValue, readInput, projectRoot } from "./common.mjs";
+import { profilePolicy, resolveExecution } from "../tools/policy.mjs";
+import { autonomyPolicy, fullTaskAutonomy } from "../tools/autonomy.mjs";
 
 const version = readText(".claude/nccgs/VERSION", 100).trim() || "unknown";
 const policy = readText(".nccgs/project.yaml");
@@ -10,8 +11,14 @@ const model = yamlValue(policy, "models", "profile") || "unconfigured";
 const input = await readInput();
 
 console.log(`NCCGS ${version} | branch ${branch} | ${changes} working-tree change(s) | model profile ${model}`);
-if (model === "astra-claude") {
-  const { profile } = profilePolicy(process.cwd());
+const execution = resolveExecution(projectRoot());
+if (fullTaskAutonomy(projectRoot())) console.log("TASK AUTONOMY: assigned work preauthorizes ordinary Bash/PowerShell, reports and required outside-project commands. Do not request repeated permission for these operations. Follow protocols/task-autonomy.md; integrity and destructive-action guards remain effective.");
+else if (autonomyPolicy(projectRoot()).mode === "full") console.log("Task autonomy is configured but not active. Start with external nccgs run; project settings alone cannot enable native bypassPermissions.");
+if (execution.name === "standalone") {
+  console.log(`Claude Code standalone | external review ${execution.externalReview.mode} | at most ${execution.maxParallelWorkers} writers. Read .claude/nccgs/MEMORY.md and protocols/standalone.md. Bind a schema-2 task; reserve Agent calls before dispatch. Unknown runtime effort/cost remains unknown.`);
+  if (/^[\w-]+$/.test(input.session_id ?? "")) console.log(`Bind the active task with: node .claude/nccgs/tools/task.mjs bind --id TASK_ID --session ${input.session_id}`);
+} else if (model === "astra-claude") {
+  const { profile } = profilePolicy(projectRoot());
   console.log(`Astra owns planning/documents. Implementation: ${profile.models.standard.model}/${profile.models.standard.effort}; independent review: ${profile.models.review.model}/${profile.models.review.effort}. Read the profile protocol and use task gates. DONE requires Astra check and explicit Product Owner acceptance.`);
   if (/^[\w-]+$/.test(input.session_id ?? "")) console.log(`Bind the active task with: node .claude/nccgs/tools/task.mjs bind --id TASK_ID --session ${input.session_id}`);
 }

package/.claude/nccgs/packages/ponytail/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DietrichGebert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,32 @@
+# Third-party attribution: Ponytail
+
+This NCCGS package **borrows and adapts selected content from Ponytail** by
+DietrichGebert. The borrowed material is not original NCCGS work. The adapted
+guidance is distributed under MIT; retain this attribution and the complete
+[upstream MIT license](LICENSE) when redistributing it.
+
+- Upstream project: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail).
+- Reviewed version: 4.10.3.
+- Pinned commit: `c982cd411abb53323c4baa1baa3c2f020b8d0b08`.
+- Upstream copyright: **Copyright (c) 2026 DietrichGebert**.
+- NCCGS adaptation date: 2026-10-04; package version: 1.0.0.
+- Source fingerprints: [manifest.json](manifest.json), SHA-256 over UTF-8 with LF
+  line endings. The LICENSE text is unchanged from upstream.
+
+| Upstream source | Selected material and NCCGS destination |
+|---|---|
+| [ponytail/SKILL.md](https://github.com/DietrichGebert/ponytail/blob/c982cd411abb53323c4baa1baa3c2f020b8d0b08/skills/ponytail/SKILL.md) | Comprehension before simplification, caller/root-cause analysis, reuse ladder, safety boundaries and deliberate-limit comments in engineering.md |
+| [ponytail-review/SKILL.md](https://github.com/DietrichGebert/ponytail/blob/c982cd411abb53323c4baa1baa3c2f020b8d0b08/skills/ponytail-review/SKILL.md) | Reuse, native features and unnecessary-complexity checks in complexity-review.md |
+| [ponytail-debt/SKILL.md](https://github.com/DietrichGebert/ponytail/blob/c982cd411abb53323c4baa1baa3c2f020b8d0b08/skills/ponytail-debt/SKILL.md) | Source-comment limits, triggers and upgrade paths in complexity-review.md |
+| [LICENSE](https://github.com/DietrichGebert/ponytail/blob/c982cd411abb53323c4baa1baa3c2f020b8d0b08/LICENSE) | Complete MIT permission and disclaimer in LICENSE |
+
+NCCGS modifications: assignment-scoped loading, full-contract precedence, Unity
+lifecycle/serialization cautions, existing verification and handoff requirements,
+bounded-repair exception, and advisory complexity findings within full independent
+review. The adaptation is maintained by NCCGS; it is not an unmodified upstream
+plugin and does not imply endorsement by the upstream author.
+
+Not imported: global persona/persistence, lite/full/ultra modes, lifecycle hooks,
+state files, MCP/server/adapters, install scripts, benchmark scoring, LOC targets,
+shortened delivery promises, one-check testing limits or output-length limits.
+No upstream benchmark saving is claimed for NCCGS.

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

@@ -0,0 +1,46 @@
+# NCCGS Ponytail shared package
+
+Selective guidance borrowed and adapted from **Ponytail by DietrichGebert**,
+v4.10.3, under the [MIT license](LICENSE). See [attribution and changes](NOTICE.md)
+and the pinned source metadata in [manifest.json](manifest.json).
+
+Choose the simplest implementation that fully satisfies the approved contract.
+Correctness, completeness and required evidence come before implementation size.
+
+## Load by assignment
+
+The coordinator and every studio agent reach this package through the constitution
+or shared agent contract. Select by the actual assignment, not the model alias,
+workflow mode alone, or a missing/unknown role. Read only the relevant module:
+
+| Assignment | Module and responsibility |
+|---|---|
+| Technical planning, architecture or root-cause analysis | [Engineering](engineering.md): technical/programming leads, architect and the assigned technical analyst |
+| Code implementation, bug fix, refactor or technical prototype | [Engineering](engineering.md): fast/Unity implementers, domain programmers and coding specialists |
+| Independent review or audit of code | [Complexity review](complexity-review.md): an additional pass within the existing independent review |
+| Maintenance of deliberate code simplifications | [Complexity review](complexity-review.md): inspect markers and report their limits in the existing handoff |
+| Game design, GDD review, story readiness, QA, playtest or release acceptance | No Ponytail module for that assignment; use the domain procedure and full acceptance obligations |
+
+An adversarial reviewer assigned a design document does not run a complexity-only
+review of that document. An unknown assignment does not activate this package by
+default. If one assignment spans code review and acceptance, the complexity pass
+covers code only; acceptance still covers every required criterion.
+
+For a bounded repair, the coordinator applies Engineering while preparing the
+chosen solution and pinned packet. The repair worker follows that packet and its
+existing limits; do not add package-reading calls or restart diagnosis in the
+worker. Missing context returns PARTIAL to the coordinator.
+
+## Integration and limits
+
+This is one shared, on-demand guidance package bundled with NCCGS. It adds no
+Ponytail plugin, global persona, lifecycle hooks, modes, dependencies, model calls,
+telemetry or separate CLI/skill commands. NCCGS install/update copies it as managed
+framework content, including its license and notice. Local overrides use the
+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,
+time and token use requires fresh real Claude Code evaluation.

package/.claude/nccgs/packages/ponytail/complexity-review.md

@@ -0,0 +1,47 @@
+# Complexity review and deliberate simplifications
+
+Adapted from [Ponytail review/debt](NOTICE.md), copyright (c) 2026 DietrichGebert,
+[MIT](LICENSE). This is a supplementary code review pass, read-only on source.
+
+## Review after checking the contract and correctness
+
+The independent reviewer still covers correctness, requirements, security,
+performance risks, regressions and evidence. Do not replace that review with this
+checklist or create another reviewer dispatch just to run it.
+
+Inspect the actual changed code and affected callers for:
+
+- Duplicated project helpers or systems: name the reusable path and confirm its
+  behavior covers the same requirement and edge cases.
+- Custom code or a dependency replaced by an appropriate stdlib/native feature:
+  identify the feature and platform/behavioral constraints.
+- Unused configuration, dead code or speculative abstraction: verify references,
+  including Unity serialized references, reflection and public compatibility
+  obligations, before recommending removal.
+- Unnecessary indirection: propose a readable equivalent, preserving state,
+  ownership, failure behavior, required tuning and test coverage.
+
+For each actionable finding, give file/line, current behavior, simpler alternative,
+why behavior is preserved, and any affected check. Incomplete evidence means an
+unverified suggestion, not a demanded deletion. Do not request code golf, remove
+required tests or refactor unchanged code merely for style. A small one-caller
+interface may still serve an actual boundary or contract.
+
+Complexity preferences are advisory unless tied to a violated requirement or a
+demonstrated actionable failure. Use the existing severity and closure rules.
+No complexity findings means only that this pass found none; it is not a product
+PASS, review approval, a LOC score, or permission to close DONE.
+
+## Inspect known limits during relevant maintenance
+
+For a maintenance/debt assignment, search source comments for `ponytail:` within
+the assigned scope. Exclude vendored dependencies and generated output such as
+Unity Library/Temp/Logs, node_modules and builds. Do not scan or rewrite the whole
+project on every code review; ordinary review checks affected markers only.
+
+Summarize relevant markers in the existing handoff: file/line, stated limit,
+revisit trigger, upgrade path and whether current evidence reaches that limit.
+Flag missing triggers or unknown measurements explicitly. No markers means no
+documented Ponytail limits were found; it does not prove an absence of debt.
+Do not apply fixes or create a new ledger without an assignment to do so. Required
+behavior remains required even if a comment describes it as deferred.

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

@@ -0,0 +1,68 @@
+# Engineering: understand, reuse, implement completely
+
+Adapted from [Ponytail](NOTICE.md), copyright (c) 2026 DietrichGebert, [MIT](LICENSE).
+Use only for the technical assignments selected by [the package entrypoint](README.md).
+
+## Preserve the contract
+
+Keep every approved requirement, gameplay rule, edge case, tuning surface and
+acceptance method. Resolve ordinary implementation choices within delegated
+authority. If a missing product decision changes behavior or acceptance, identify
+the ambiguity and stop that dependent work; do not silently choose a reduced
+feature or redefine the criterion to match the implementation.
+
+Never remove trust-boundary validation, data-loss protection, security,
+accessibility, serialization/save compatibility or required platform behavior for
+a shorter diff. Existing interfaces, engine lifecycle rules and tested project
+patterns can justify abstraction even when only one current caller exists.
+
+## Understand the affected flow
+
+Read the assigned contract and relevant code before choosing a solution. Trace the
+trigger, state changes, outputs and failure paths. For a bug, find callers and
+shared state of the function being changed, including sibling paths and relevant
+tests. Fix the shared root cause where the evidence supports it. Do not broaden a
+search into a whole-project audit without a concrete unresolved dependency.
+
+A bounded repair uses the coordinator's pinned diagnosis and chosen solution.
+Respect its exact files and tool budget. If that solution conflicts with the
+observed code, report PARTIAL; do not expand scope or experiment outside the packet.
+
+## Prefer the first option that covers the full requirement
+
+1. Check whether the proposed *extra mechanism* is necessary. Omit speculative
+   scope, never an approved feature or acceptance obligation.
+2. Reuse an existing project helper, system or established pattern after checking
+   its actual behavior, ownership, lifecycle and supported inputs.
+3. Prefer a suitable standard-library or native Unity/platform feature over
+   custom infrastructure; verify platform/version and behavioral compatibility.
+4. Use an already installed dependency when it covers the need. A new dependency
+   follows existing project approval policy; this package grants no extra authority.
+5. Otherwise write a small, readable implementation. Add abstraction/configuration
+   for demonstrated variation, required tuning or an existing contract, not for an
+   imagined future. Do not compress readable code merely to reduce line count.
+
+Compare complexity only among solutions that satisfy the same contract. Reuse is
+not correct if it changes timing, random selection, persistence or player feedback.
+Use official Unity Skills for Editor/asset operations; never hand-edit serialized
+scenes, prefabs, assets or metadata as a shortcut.
+
+## Verify and hand off
+
+Use the project's existing test tools and the checks required by the task. Add a
+focused regression for meaningful changed logic and affected caller behavior when
+needed; avoid tests that only mirror the implementation. Required Unity compilation,
+EditMode/PlayMode, build, runtime and manual checks remain required. A single smoke
+check, fewer lines or a passing helper exit code cannot substitute for them.
+In bounded repair, the coordinator runs the checks after the worker returns.
+
+Mark a deliberate simplification only when it has a real known limit:
+`// ponytail: <limit and affected behavior>; revisit when <measurable trigger>; upgrade <path>.`
+Keep required tuning controls. A marker documents a valid tradeoff within the
+approved contract; it cannot authorize missing behavior or defer a failed criterion.
+Mention relevant limits in the existing Risks and deviations handoff field.
+
+Report what changed, reuse/root-cause rationale when material, executed evidence,
+unverified behavior and remaining decisions. Keep the existing NCCGS handoff and
+status format, including COMPLETE versus product PASS. Do not impose a three-line
+limit, suppress failures or generate an extra report solely for this package.

package/.claude/nccgs/packages/ponytail/manifest.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": 1,
+  "name": "nccgs-ponytail",
+  "version": "1.0.0",
+  "kind": "shared-guidance",
+  "entrypoint": "README.md",
+  "license": "MIT",
+  "licenseFile": "LICENSE",
+  "noticeFile": "NOTICE.md",
+  "files": ["manifest.json", "README.md", "engineering.md", "complexity-review.md", "NOTICE.md", "LICENSE"],
+  "upstream": {
+    "name": "Ponytail",
+    "repository": "https://github.com/DietrichGebert/ponytail",
+    "version": "4.10.3",
+    "commit": "c982cd411abb53323c4baa1baa3c2f020b8d0b08",
+    "copyright": "Copyright (c) 2026 DietrichGebert",
+    "sources": [
+      { "path": "LICENSE", "sha256LF": "fb1bc6909ac3ef82d5c22106e32ef682b0cff66788fa915fb9b53b15c9d2f3ab" },
+      { "path": "skills/ponytail/SKILL.md", "sha256LF": "1316a2f3f95741d2300b116fe0c2d81ce4a9568656ed0a62643f54aaf09957f2" },
+      { "path": "skills/ponytail-review/SKILL.md", "sha256LF": "7f8bfd0da3ba7c6fe0cd0de53e6f910adfef52166c6e99d7fa4de3360650b9b6" },
+      { "path": "skills/ponytail-debt/SKILL.md", "sha256LF": "d3611761039bdb2955e31856834feeec6ed5483a3fc64576e9a166f949a131d1" }
+    ]
+  }
+}

package/.claude/nccgs/pipeline.json

@@ -1,24 +1,24 @@
 {
   "schemaVersion": 1,
-  "defaultProfile": "astra-claude",
+  "defaultProfile": "claude-standalone",
   "profiles": {
     "astra-claude": {
       "models": {
         "lightweight": {
-          "model": "claude-opus-5-5",
-          "effort": "xhigh"
+          "model": "sonnet",
+          "effort": "medium"
         },
         "standard": {
           "model": "claude-opus-5-5",
-          "effort": "xhigh"
+          "effort": "medium"
         },
         "deep": {
           "model": "claude-opus-5-5",
-          "effort": "xhigh"
+          "effort": "high"
         },
         "leadership": {
           "model": "claude-opus-5-5",
-          "effort": "xhigh"
+          "effort": "high"
         },
         "review": {
           "model": "fable",
@@ -29,6 +29,9 @@
         "class": "standard"
       },
       "activeAgents": [
+        "nccgs-fast-implementer",
+        "nccgs-task-scout",
+        "nccgs-game-designer",
         "nccgs-gameplay-programmer",
         "nccgs-engine-programmer",
         "nccgs-ui-programmer",
@@ -118,6 +121,48 @@
       },
       "session": null,
       "activeAgents": "all"
+    },
+    "claude-standalone": {
+      "models": {
+        "lightweight": {
+          "effort": "medium",
+          "model": "sonnet"
+        },
+        "standard": {
+          "effort": "medium",
+          "model": "opus"
+        },
+        "deep": {
+          "effort": "high",
+          "model": "opus"
+        },
+        "leadership": {
+          "effort": "high",
+          "model": "opus"
+        },
+        "review": {
+          "effort": "high",
+          "model": "opus"
+        }
+      },
+      "session": {
+        "class": "standard"
+      },
+      "activeAgents": [
+        "nccgs-fast-implementer",
+        "nccgs-task-scout",
+        "nccgs-game-designer",
+        "nccgs-gameplay-programmer",
+        "nccgs-engine-programmer",
+        "nccgs-ui-programmer",
+        "nccgs-unity-implementer",
+        "nccgs-unity-systems-specialist",
+        "nccgs-unity-ui-specialist",
+        "nccgs-unity-build-specialist",
+        "nccgs-qa-engineer",
+        "nccgs-verification-engineer",
+        "nccgs-adversarial-reviewer"
+      ]
     }
   },
   "contract": {
@@ -126,7 +171,7 @@
     "reviewAgent": "nccgs-adversarial-reviewer",
     "sequence": [
       "astra-plan",
-      "opus-implementation",
+      "risk-routed-implementation",
       "fable-review",
       "report-to-astra",
       "astra-check",
@@ -134,6 +179,20 @@
     ],
     "requiredForAllCodeChanges": true,
     "allowInheritFallback": false,
+    "taskTiers": {
+      "FAST": {
+        "implementationClass": "lightweight",
+        "maxReviewRounds": 2
+      },
+      "STANDARD": {
+        "implementationClass": "standard",
+        "maxReviewRounds": 3
+      },
+      "CONTROLLED": {
+        "implementationClass": "deep",
+        "maxReviewRounds": 3
+      }
+    },
     "astraWorkflows": [
       "design",
       "context-pack",
@@ -162,6 +221,9 @@
     ".vs"
   ],
   "coreAgents": [
+    "nccgs-fast-implementer",
+    "nccgs-task-scout",
+    "nccgs-game-designer",
     "nccgs-gameplay-programmer",
     "nccgs-engine-programmer",
     "nccgs-ui-programmer",
@@ -172,5 +234,27 @@
     "nccgs-qa-engineer",
     "nccgs-verification-engineer",
     "nccgs-adversarial-reviewer"
-  ]
+  ],
+  "executionPolicies": {
+    "standalone": {
+      "reviewAgent": "nccgs-adversarial-reviewer",
+      "documentsOwner": "Claude Code",
+      "runtime": "claude-code",
+      "sequence": [
+        "intake",
+        "plan",
+        "implementation",
+        "verification",
+        "independent-review",
+        "report",
+        "optional-external-review",
+        "contract-acceptance"
+      ],
+      "planningOwner": "Claude Code"
+    },
+    "compatibility": {
+      "contract": "astra-claude",
+      "runtime": "claude-code"
+    }
+  }
 }

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

@@ -4,7 +4,11 @@ All studio agents use this contract in addition to their role file.
 
 ## Inputs
 
-For the `astra-claude` profile, first read `protocols/astra-claude.md` relative to
+For standalone execution, first read `protocols/standalone.md`; the coordinator
+reserves every worker and owns lifecycle records. Audit/plan/review workers may
+write only declared analysis artifacts. Return facts and unresolved findings.
+
+For compatibility execution with `astra-claude`, first read `protocols/astra-claude.md` relative to
 `.claude/nccgs/`. Astra supplies planning and canonical documents. Claude produces
 implementation, evidence, and handoff reports; Fable independently reviews. Never
 impersonate Astra or infer Product Owner acceptance.
@@ -28,12 +32,57 @@ load every project document.
 
 ## Work standard
 
+For design documents, document review or story readiness in standalone execution,
+follow [the design lifecycle](design-lifecycle.md), including semantic coverage,
+decision authority and the reviewed handoff. Schema validation alone is not review.
+
+For technical planning, coding, code review or code-debt maintenance, read the
+relevant module selected by the [shared Ponytail package](../packages/ponytail/README.md)
+before acting. This applies in either execution policy. Game design, document
+readiness and QA/acceptance do not use Ponytail as their procedure. For bounded
+repair, the coordinator applies the package before pinning the solution; the
+worker follows the supplied packet without extra package reads or diagnosis.
+
 Separate facts, inferences, recommendations, edits, and evidence. Follow project
 patterns before generic preferences. Use official Unity Skills for Unity operation
 mechanics. Record deviations instead of silently normalizing the project.
 
+Do not add speculative scope. Use the scout only to answer a specific missing fact,
+and propose another reviewer only for a distinct risk. Stop once assigned criteria
+and relevant checks pass without actionable blockers. Rerun checks only when
+inputs change, a failure needs resolution, or new evidence warrants it. Subjective
+questions should become a playable Product Owner test. Return budget exhaustion
+with evidence and unresolved findings; do not spend more rounds or infer approval.
+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
+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
 
+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;
+do not spend a bounded worker invocation polling engine jobs owned by the coordinator.
+Replace that line with `NCCGS-HANDOFF: COMPLETE` only after the assigned bounded
+work is finished and remaining product failures are explicitly documented. A complete
+negative review is valid; COMPLETE is not a product PASS or permission to close DONE.
+Missing/partial handoffs fail the attempt even when native transport says completed.
+Native harness turn exhaustion also makes the attempt incomplete even if the file
+says COMPLETE. For every review assignment follow [review handoff](review-handoff.md):
+the reviewer owns the structured verdict and explicit remaining conditions; a
+conditional PASS is not permitted under the new standalone review policy.
+
+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
+attempt and its findings. Never resume a worker outside reservation tracking, edit
+its captured handoff after completion, reset quota, or spend protected repair slots
+on extra ordinary delivery. Stop partial if no eligible attempt remains.
+
 Return: **Outcome**, **Changed/produced**, **Evidence**, **Risks and deviations**,
 **Decisions needed**, and **Next owner**. Do not claim `DONE`; only the closure
 workflow evaluates final project gates.