nccgs 1.1.1 → 1.3.0

package/scaffold/.nccgs/state.md

@@ -14,7 +14,7 @@ Updated: [timestamp]
 
 - Last completed checkpoint: NCCGS initialized
 - Current step: configure or migrate project policy
-- Next safe action: run `/migrate-project review` for an existing project
+- Next safe action: Astra prepares project policy, gate mapping and migration plan; Claude then runs `/migrate-project`
 
 ## Decisions pending
 

package/scaffold/.nccgs/templates/agent-handoff.md

@@ -23,3 +23,13 @@
 ## Next owner
 
 [role or workflow]
+
+## Model and review trace (astra-claude profile)
+
+- Requested model/effort:
+- Observed model/effort and session/agent reference:
+- Plan and working snapshot:
+- Fable review record and verdict:
+- Report path for Astra (after Fable PASS only):
+- Astra check: PENDING unless referenced
+- Product Owner acceptance: PENDING unless explicitly referenced

package/scaffold/.nccgs/templates/closure-record.md

@@ -49,3 +49,14 @@
 ## Known issues and residual risk
 
 - None
+
+## Astra/Claude chain (required for astra-claude)
+
+- **Final snapshot**: [commit plus dirty/untracked diff or file hashes]
+- **Fable review**: PENDING/PASS/CHANGES_REQUIRED/BLOCKED [record and snapshot]
+- **Report to Astra**: [path; issued only after Fable PASS]
+- **Astra check**: PENDING/PASS/CHANGES_REQUIRED [Astra reference and snapshot]
+- **Product Owner acceptance**: PENDING/ACCEPTED/REJECTED [user reference and snapshot]
+- **Current phase**: IMPLEMENTING/FABLE_REVIEW/AWAITING_ASTRA_CHECK/AWAITING_PO_ACCEPTANCE/CLOSED
+
+All sign-offs must cover the same final snapshot. Pending or stale gates prevent DONE.

package/scaffold/.nccgs/templates/feature-contract.md

@@ -33,3 +33,12 @@
 ## Open PO decisions
 
 - None
+
+## Astra/Claude ownership (astra-claude profile)
+
+- Plan and canonical documents: Astra [plan revision/reference]
+- Implementation and remediation: Claude Opus 5.5 / xhigh
+- Independent review: Fable / high
+- Report checking and document synchronization: Astra
+- Final acceptance: Product Owner [explicit decision required]
+- Review/report snapshot identification: [commit plus dirty/untracked diff or hashes]

package/scaffold/.nccgs/templates/implementation-report.md

@@ -0,0 +1,49 @@
+# Implementation report for Astra: [feature ID]
+
+- **Phase**: AWAITING_ASTRA_CHECK
+- **Task ID and record**: [ID; .nccgs/tasks/ID.json]
+- **Report gate**: [task check --id ID --target report result]
+- **Technical state**: IMPLEMENTED | VERIFIED | BLOCKED
+- **Astra plan and revision**: [path/reference]
+- **Implemented snapshot**: [SHA-256 from task snapshot]
+- **Implementation model / effort (requested)**: [from pipeline.json]
+- **Implementation model / effort (observed)**: [runtime evidence; unknown is not proof]
+- **Implementation session / agent**: [ID/reference]
+
+## Plan compliance and changes
+
+| Requirement | Changed files/behavior | Evidence and result | Deviations |
+|---|---|---|---|
+| [REQ-ID] | [change] | [direct reference] | [none or explanation] |
+
+## Verification
+
+- Commands/scenarios, environment, counts, failures, skips, runtime/build results:
+- Relevant regression and unverified behavior:
+
+## Independent Fable review
+
+- Requested model / effort: [review route from pipeline.json]
+- Observed model / effort and session / agent: [runtime evidence]
+- Reviewed snapshot: [must match implemented snapshot]
+- Verdict: PASS | CHANGES_REQUIRED | BLOCKED
+- Review record: [path or verbatim independent findings]
+- Findings, Opus fixes, repeated checks, and Fable re-review references:
+- Remaining non-blocking findings and residual risk:
+
+## Documents for Astra
+
+- Proposed canonical document updates with exact sections and reasons:
+- Changed scope or decisions requiring Astra/Product Owner resolution:
+
+## Downstream decisions — stored separately
+
+Do not amend this report after recording its hash. Astra check and Product Owner
+acceptance are separate JSON evidence files linked by the task record. Both are
+pending when this report is handed over; never author their decisions for them.
+
+- Reproduction/acceptance steps:
+
+## Next owner
+
+Astra. Do not mark DONE while either downstream sign-off is pending.

package/scripts/cli.mjs

@@ -19,14 +19,16 @@ if (command === "version" || command === "--version" || command === "-v") {
   process.exit(0);
 }
 
-if (!new Set(["install", "update", "doctor"]).has(command)) {
+if (!new Set(["install", "update", "doctor", "task", "agents", "policy"]).has(command)) {
   console.error(`Unknown command: ${command}`);
   printHelp();
   process.exit(2);
 }
 
-const script = command === "doctor" ? "doctor.mjs" : "install.mjs";
-const forwardedArgs = command === "update" ? ["--update-only", ...args] : args;
+const scripts = { doctor: "doctor.mjs", task: "../.claude/nccgs/tools/task.mjs", agents: "../.claude/nccgs/tools/configure-models.mjs", policy: "../.claude/nccgs/tools/compile-policy.mjs" };
+const script = scripts[command] || "install.mjs";
+let forwardedArgs = command === "update" ? ["--update-only", ...args] : args;
+if (command === "agents" && !args.includes("--project")) forwardedArgs = ["--project", process.cwd(), ...args];
 const result = spawnSync(process.execPath, [path.join(scriptDir, script), ...forwardedArgs], {
   cwd: process.cwd(),
   stdio: "inherit"
@@ -45,6 +47,9 @@ Usage:
   nccgs install [options]
   nccgs update [options]
   nccgs doctor [options]
+  nccgs task init|snapshot|ref|observe|verify|record|check|close|bind [options]
+  nccgs agents --enable <role> | --disable <role> [--project <directory>]
+  nccgs policy [--write]              Check/regenerate package routing
   nccgs --version
 
 Install target:
@@ -54,7 +59,7 @@ Install target:
 Options:
   --dry-run                         Preview without writing files
   --force                           Back up and discard detected project overrides
-  --model-profile <profile>         quality, balanced, or inherit
+  --model-profile <profile>         astra-claude (default), quality, balanced, inherit
   --project <directory>             Optional explicit target directory
   --allow-non-unity                 Allow a target without Unity markers`);
 }

package/scripts/doctor.mjs

@@ -3,6 +3,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { matchesFingerprint, sameFingerprint } from "../.claude/nccgs/tools/integrity.mjs";
+import { check as checkTask, snapshot, stages } from "../.claude/nccgs/tools/gates.mjs";
+import { contained, hash, json } from "../.claude/nccgs/tools/policy.mjs";
 
 const args = process.argv.slice(2);
 const projectIndex = args.indexOf("--project");
@@ -75,11 +77,35 @@ const policyPath = path.join(project, ".nccgs", "project.yaml");
 let policySchema = null;
 if (!fs.existsSync(policyPath)) errors.push(".nccgs/project.yaml is missing.");
 else {
-  const match = fs.readFileSync(policyPath, "utf8").match(/^schema_version:\s*(\d+)\s*$/m);
+  const policyText = fs.readFileSync(policyPath, "utf8");
+  const match = policyText.match(/^schema_version:\s*(\d+)\s*$/m);
   policySchema = match ? Number(match[1]) : null;
   if (policySchema !== 2) migrationIssue(`Project policy schema must be 2; found ${policySchema ?? "unknown"}.`);
+  if (/^profile_contracts:/m.test(policyText)) migrationIssue("Legacy embedded profile_contracts require Astra migration to pipeline.json plus project gate mapping.");
 }
 
+const activationPath = path.join(project, ".nccgs/agent-activation.json");
+if (fs.existsSync(activationPath)) {
+  try {
+    const activation = json(activationPath);
+    for (const [relative, expected] of Object.entries(activation.generated)) {
+      const bytes = fs.readFileSync(contained(project, relative));
+      if (hash(bytes) !== expected && hash(bytes.toString("utf8").replace(/\r\n/g, "\n")) !== activation.generatedCanonical?.[relative]) errors.push(`Activated agent modified: ${relative}`);
+    }
+    for (const warning of activation.warnings ?? []) migrationIssue(warning);
+  } catch (error) { errors.push(`Invalid agent activation state: ${error.message}`); }
+}
+const tasksDir = path.join(project, ".nccgs/tasks");
+if (fs.existsSync(tasksDir)) for (const file of fs.readdirSync(tasksDir).filter(f => f.endsWith(".json"))) {
+  try {
+    const task = json(path.join(tasksDir, file));
+    if (task.closed) {
+      if (!stages.every(s => task.stages?.[s]) || task.closed.snapshot !== task.stages.acceptance.snapshot) throw new Error("Closure lacks its required stage records");
+      if (task.closed.snapshot === snapshot(project).sha256) checkTask(project, task, "done");
+      else warnings.push(`Historical closure ${task.id} is for a different snapshot; it cannot approve current work.`);
+    }
+  } catch (error) { errors.push(`Invalid closed task ${file}: ${error.message}`); }
+}
 if (errors.length) {
   for (const error of errors) console.error(`ERROR: ${error}`);
   for (const warning of warnings) console.warn(`WARN: ${warning}`);

package/scripts/install.mjs

@@ -164,8 +164,9 @@ const settingsPlan = planManagedSettings(project);
 const targetPolicyPath = path.join(project, ".nccgs", "project.yaml");
 const targetPolicy = fs.existsSync(targetPolicyPath) ? fs.readFileSync(targetPolicyPath, "utf8") : "";
 const policyModelProfile = targetPolicy.match(/^models:\s*$[\s\S]*?^\s+profile:\s*([^#\r\n]+)/m)?.[1]?.trim();
-const modelProfile = requestedModelProfile || policyModelProfile || "quality";
-if (!new Set(["quality", "balanced", "inherit"]).has(modelProfile)) {
+const studio = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/studio.json"), "utf8"));
+const modelProfile = requestedModelProfile || policyModelProfile || studio.defaultProfile;
+if (!Object.hasOwn(studio.modelProfiles, modelProfile)) {
   console.error(`Unknown model profile: ${modelProfile}`);
   process.exit(2);
 }
@@ -248,7 +249,7 @@ if (fs.existsSync(backupRoot)) {
 }
 const installedPolicy = fs.readFileSync(targetPolicyPath, "utf8");
 const installedPolicySchema = Number(installedPolicy.match(/^schema_version:\s*(\d+)\s*$/m)?.[1] ?? 0);
-if (installedPolicySchema !== 2 || pendingOverrides.length) {
+if (installedPolicySchema !== 2 || pendingOverrides.length || /^profile_contracts:/m.test(installedPolicy)) {
   console.log("Project migration required: open a new Claude Code session and run `/migrate-project` once.");
 } else if (!previousInstallState) {
   console.log("First NCCGS adoption: run `/migrate-project` once for an existing project; a new project can start with `/status`.");

package/scripts/validate.mjs

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { compile } from "../.claude/nccgs/tools/compile-policy.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const errors = [];
@@ -44,9 +45,13 @@ for (const relative of [
   "VERSION", "README.md", "CLAUDE.md", "LICENSE", "package.json",
   ".claude/nccgs/VERSION", ".claude/nccgs/constitution.md",
   ".claude/nccgs/studio.json", ".claude/nccgs/workflow-catalog.json",
+  ".claude/nccgs/pipeline.json", ".claude/nccgs/protocols/task-gates.md",
+  ".claude/nccgs/tools/task.mjs", ".claude/nccgs/tools/gates.mjs", ".claude/nccgs/tools/runtime.mjs",
+  "scaffold/.nccgs/gates.json", "tests/gates.test.mjs",
   ".claude/nccgs/settings.fragment.json", ".claude/nccgs/unity-skills-manifest.json",
   ".claude/nccgs/protocols/agent-contract.md", ".claude/nccgs/protocols/orchestration.md",
   ".claude/nccgs/protocols/model-routing.md", ".claude/nccgs/protocols/context-packets.md",
+  ".claude/nccgs/protocols/astra-claude.md", "scaffold/.nccgs/templates/implementation-report.md",
   ".claude/nccgs/protocols/evidence.md", ".claude/nccgs/protocols/unity-boundary.md",
   "scaffold/.nccgs/project.yaml", "scaffold/.nccgs/state.md",
   "scaffold/.nccgs/requirements.yaml", "scaffold/.nccgs/templates/context-packet.yaml",
@@ -78,17 +83,22 @@ const rootClaude = fs.readFileSync(path.join(root, "CLAUDE.md"), "utf8");
 if (!rootClaude.includes("@.claude/nccgs/constitution.md")) errors.push("CLAUDE.md does not import the NCCGS constitution.");
 
 const studio = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/studio.json"), "utf8"));
+const pipeline = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/pipeline.json"), "utf8"));
+for (const stale of compile(root)) errors.push(`Stale generated policy: ${stale}; run npm run policy:build`);
 const agentNames = new Set();
 for (const agent of studio.agents ?? []) {
   if (agentNames.has(agent.name)) errors.push(`Duplicate catalog agent: ${agent.name}`);
   agentNames.add(agent.name);
-  const file = path.join(root, ".claude", "agents", `${agent.name}.md`);
+  const active = pipeline.profiles[pipeline.defaultProfile].activeAgents.includes(agent.name);
+  const file = path.join(root, active ? ".claude/agents" : ".claude/nccgs/agent-library", `${agent.name}.md`);
   if (!fs.existsSync(file)) { errors.push(`Catalog agent file missing: ${agent.name}`); continue; }
   const metadata = frontmatter(file);
   if (metadata?.name !== agent.name || !metadata?.description) errors.push(`Invalid agent frontmatter: ${agent.name}`);
   const expected = studio.modelProfiles[studio.defaultProfile]?.[agent.modelClass];
-  if (metadata?.model !== expected) errors.push(`Agent model mismatch: ${agent.name} expected ${expected}, found ${metadata?.model}`);
-  if ((metadata?.tools ?? "").split(/,\s*/).includes("Task")) errors.push(`Agent may recursively delegate: ${agent.name}`);
+  if (active && metadata?.model !== expected) errors.push(`Agent model mismatch: ${agent.name} expected ${expected}, found ${metadata?.model}`);
+  const expectedEffort = studio.effortProfiles?.[studio.defaultProfile]?.[agent.modelClass];
+  if (active && metadata?.effort !== expectedEffort) errors.push(`Agent effort mismatch: ${agent.name} expected ${expectedEffort}, found ${metadata?.effort}`);
+  if ((metadata?.tools ?? "").split(/,\s*/).some(tool => ["Task", "Agent"].includes(tool))) errors.push(`Agent may recursively delegate: ${agent.name}`);
   if (!fs.readFileSync(file, "utf8").includes("protocols/agent-contract.md")) errors.push(`Agent does not load common contract: ${agent.name}`);
   if (fs.readFileSync(file, "utf8").split(/\r?\n/).length > 80) errors.push(`Agent entrypoint exceeds 80 lines: ${agent.name}`);
 }
@@ -96,6 +106,7 @@ for (const agent of studio.agents ?? []) {
 const actualAgents = walk(path.join(root, ".claude/agents")).filter((file) => file.endsWith(".md"));
 for (const file of actualAgents) {
   if (!agentNames.has(path.basename(file, ".md"))) errors.push(`Uncataloged NCCGS agent: ${posix(path.relative(root, file))}`);
+  if (!pipeline.coreAgents.includes(path.basename(file, ".md"))) errors.push(`Non-core agent active in source package: ${posix(path.relative(root, file))}`);
 }
 
 const workflows = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/workflow-catalog.json"), "utf8"));
@@ -111,6 +122,10 @@ for (const workflow of workflows.workflows ?? []) {
   if (lines > 120) errors.push(`Workflow entrypoint exceeds 120 lines: ${workflow.name}`);
   if (fs.existsSync(path.join(path.dirname(file), "README.md"))) errors.push(`NCCGS-owned skill contains redundant README: ${workflow.name}`);
   for (const role of workflow.primaryRoles ?? []) if (!agentNames.has(role)) errors.push(`Workflow ${workflow.name} references unknown role ${role}`);
+  for (const [profile, roles] of Object.entries(workflow.primaryRolesByProfile ?? {})) {
+    if (!studio.modelProfiles[profile]) errors.push(`Workflow ${workflow.name} references unknown profile ${profile}`);
+    for (const role of roles) if (!agentNames.has(role)) errors.push(`Workflow ${workflow.name} references unknown role ${role}`);
+  }
 }
 for (const entry of workflows.entrypoints ?? []) if (!workflowNames.has(entry)) errors.push(`Missing entrypoint workflow: ${entry}`);
 
@@ -137,9 +152,7 @@ for (const command of hookCommands) {
   if (check.status !== 0) errors.push(`Hook syntax failure ${match[1]}: ${check.stderr.trim()}`);
 }
 for (const file of [
-  path.join(root, ".claude/nccgs/tools/configure-models.mjs"),
-  path.join(root, ".claude/nccgs/tools/integrity.mjs"),
-  path.join(root, ".claude/nccgs/tools/approve-overrides.mjs"),
+  ...walk(path.join(root, ".claude/nccgs/tools")).filter(file => file.endsWith(".mjs")),
   path.join(root, "scripts/cli.mjs"),
   path.join(root, "scripts/doctor.mjs"),
   path.join(root, "scripts/install.mjs")
@@ -213,7 +226,7 @@ if (errors.length) {
 
 console.log("NCCGS validation passed.");
 console.log(`NCCGS workflows: ${workflowNames.size} (${workflows.entrypoints.length} entrypoints)`);
-console.log(`Studio agents: ${agentNames.size}`);
+console.log(`Studio agents: ${agentNames.size} in library; ${pipeline.coreAgents.length} active by default`);
 console.log(`Path-scoped rules: ${rules.length}`);
 console.log(`Managed hooks: ${hookCommands.length}`);
 console.log(`Vendored Unity Skills: ${manifest?.skills?.length ?? 0}`);

package/tests/framework.test.mjs

@@ -6,13 +6,46 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
+import { compile, renderAgent } from "../.claude/nccgs/tools/compile-policy.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const studio = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/studio.json"), "utf8"));
 const workflows = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/workflow-catalog.json"), "utf8"));
+const pipeline = JSON.parse(fs.readFileSync(path.join(root, ".claude/nccgs/pipeline.json"), "utf8"));
+function copyAgentFixture(temp) {
+  fs.cpSync(path.join(root, ".claude/nccgs"), path.join(temp, ".claude/nccgs"), { recursive: true });
+  fs.mkdirSync(path.join(temp, ".claude/agents"), { recursive: true });
+  for (const agent of studio.agents) {
+    const template = fs.readFileSync(path.join(root, ".claude/nccgs/agent-library", `${agent.name}.md`), "utf8");
+    fs.writeFileSync(path.join(temp, ".claude/agents", `${agent.name}.md`), renderAgent(template, pipeline.profiles["astra-claude"].models[agent.modelClass]));
+  }
+}
 const frameworkVersion = fs.readFileSync(path.join(root, "VERSION"), "utf8").trim();
 const sha256 = (value) => crypto.createHash("sha256").update(value).digest("hex");
 
+test("canonical policy changes invalidate generated routing until compilation", () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-policy-test-"));
+  try {
+    copyAgentFixture(temp);
+    compile(temp, true);
+    assert.deepEqual(compile(temp), []);
+    const file = path.join(temp, ".claude/nccgs/pipeline.json");
+    const policy = JSON.parse(fs.readFileSync(file, "utf8"));
+    policy.profiles["astra-claude"].models.review.effort = "medium";
+    fs.writeFileSync(file, JSON.stringify(policy));
+    const stale = compile(temp);
+    assert.ok(stale.includes(".claude/agents/nccgs-adversarial-reviewer.md"));
+    assert.ok(stale.includes(".claude/nccgs/workflow-catalog.json"));
+    compile(temp, true);
+    assert.deepEqual(compile(temp), []);
+    const catalog = JSON.parse(fs.readFileSync(path.join(temp, ".claude/nccgs/studio.json"), "utf8"));
+    assert.equal(catalog.effortProfiles["astra-claude"].review, "medium");
+  } finally {
+    assert.ok(path.resolve(temp).startsWith(path.resolve(os.tmpdir()) + path.sep + "nccgs-policy-test-"));
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
 test("studio roles are unique and workflow references resolve", () => {
   const roles = new Set(studio.agents.map((agent) => agent.name));
   assert.equal(roles.size, studio.agents.length);
@@ -27,8 +60,116 @@ test("quality profile assigns all model classes", () => {
   }
 });
 
+test("optional specialists survive updates and can be disabled without changing core agents", () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-optional-agents-"));
+  try {
+    for (const marker of ["Assets", "Packages", "ProjectSettings"]) fs.mkdirSync(path.join(temp, marker));
+    const run = (...args) => spawnSync(process.execPath, [path.join(root, "scripts/cli.mjs"), ...args], { cwd: temp, encoding: "utf8" });
+    const install = run("install");
+    assert.equal(install.status, 0, install.stderr || install.stdout);
+    const role = "nccgs-network-programmer";
+    const file = path.join(temp, ".claude/agents", `${role}.md`);
+    assert.ok(!fs.existsSync(file));
+    assert.equal(run("agents", "--enable", role).status, 0);
+    assert.match(fs.readFileSync(file, "utf8"), /model: claude-opus-5-5/);
+    const update = run("update");
+    assert.equal(update.status, 0, update.stderr || update.stdout);
+    assert.ok(fs.existsSync(file));
+    assert.equal(run("doctor").status, 0);
+    assert.equal(run("agents", "--disable", role).status, 0);
+    assert.ok(!fs.existsSync(file));
+    assert.notEqual(run("agents", "--disable", "nccgs-adversarial-reviewer").status, 0);
+    assert.equal(fs.readdirSync(path.join(temp, ".claude/agents")).length, pipeline.coreAgents.length);
+  } finally { fs.rmSync(temp, { recursive: true, force: true }); }
+});
+
+test("default install configures Opus coding and independent Fable review without erasing settings", () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-astra-install-"));
+  try {
+    for (const marker of ["Assets", "Packages", "ProjectSettings", ".claude"]) fs.mkdirSync(path.join(temp, marker));
+    const settingsPath = path.join(temp, ".claude/settings.json");
+    fs.writeFileSync(settingsPath, JSON.stringify({ model: "sonnet", effortLevel: "medium", modelSettings: { "claude-opus-5-5": { effortLevel: "low" }, "claude-sonnet-4-6": { effortLevel: "medium" } }, permissions: { allow: ["Bash(git status*)"] }, env: { NCCGS_TEST: "preserved" } }));
+    const run = (...args) => spawnSync(process.execPath, [path.join(root, "scripts/cli.mjs"), ...args], { cwd: temp, encoding: "utf8" });
+    const dry = run("install", "--dry-run");
+    assert.equal(dry.status, 0, dry.stderr || dry.stdout);
+    assert.equal(JSON.parse(fs.readFileSync(settingsPath)).model, "sonnet");
+    assert.ok(!fs.existsSync(path.join(temp, ".claude/agents")));
+    const install = run("install");
+    assert.equal(install.status, 0, install.stderr || install.stdout);
+    const settings = JSON.parse(fs.readFileSync(settingsPath));
+    assert.equal(settings.model, "claude-opus-5-5");
+    assert.equal(settings.effortLevel, "xhigh");
+    assert.equal(settings.modelSettings["claude-opus-5-5"].effortLevel, "xhigh");
+    assert.equal(settings.modelSettings["claude-sonnet-4-6"].effortLevel, "medium");
+    assert.equal(settings.env.NCCGS_TEST, "preserved");
+    assert.deepEqual(settings.permissions.allow, ["Bash(git status*)"]);
+    for (const agent of studio.agents) {
+      if (!pipeline.coreAgents.includes(agent.name)) {
+        assert.ok(!fs.existsSync(path.join(temp, ".claude/agents", `${agent.name}.md`)));
+        continue;
+      }
+      const text = fs.readFileSync(path.join(temp, ".claude/agents", `${agent.name}.md`), "utf8");
+      const expected = agent.name === "nccgs-adversarial-reviewer" ? "fable" : "claude-opus-5-5";
+      assert.equal(text.match(/^model:\s*(\S+)/m)?.[1], expected, agent.name);
+      const expectedEffort = agent.name === "nccgs-adversarial-reviewer" ? "high" : "xhigh";
+      assert.equal(text.match(/^effort:\s*(\S+)/m)?.[1], expectedEffort, agent.name);
+    }
+    assert.match(fs.readFileSync(path.join(temp, ".nccgs/project.yaml"), "utf8"), /profile: astra-claude/);
+    assert.ok(fs.existsSync(path.join(temp, ".nccgs/templates/implementation-report.md")));
+    const update = run("update");
+    assert.equal(update.status, 0, update.stderr || update.stdout);
+    assert.match(update.stdout, /0 preserved override/);
+    const doctor = run("doctor");
+    assert.equal(doctor.status, 0, doctor.stderr || doctor.stdout);
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
+test("profile changes clear effort pins and preserve skipped custom agents", () => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-effort-profile-"));
+  try {
+    fs.mkdirSync(path.join(temp, ".claude/nccgs"), { recursive: true });
+    fs.mkdirSync(path.join(temp, ".claude/agents"));
+    fs.mkdirSync(path.join(temp, ".nccgs"));
+    fs.copyFileSync(path.join(root, ".claude/nccgs/studio.json"), path.join(temp, ".claude/nccgs/studio.json"));
+    fs.writeFileSync(path.join(temp, ".nccgs/project.yaml"), "models:\n  profile: astra-claude\n");
+    copyAgentFixture(temp);
+    const run = (profile, ...args) => spawnSync(process.execPath, [path.join(root, ".claude/nccgs/tools/configure-models.mjs"), "--project", temp, "--profile", profile, ...args], { encoding: "utf8" });
+    for (const profile of ["inherit", "quality", "balanced", "astra-claude"]) {
+      const result = run(profile);
+      assert.equal(result.status, 0, result.stderr || result.stdout);
+      for (const agent of studio.agents) {
+        if (profile === "astra-claude" && !pipeline.coreAgents.includes(agent.name)) {
+          assert.ok(!fs.existsSync(path.join(temp, ".claude/agents", `${agent.name}.md`)));
+          continue;
+        }
+        const text = fs.readFileSync(path.join(temp, ".claude/agents", `${agent.name}.md`), "utf8");
+        assert.equal(text.match(/^model:\s*(\S+)/m)?.[1] ?? null, studio.modelProfiles[profile][agent.modelClass], agent.name);
+        const expectedEffort = profile === "astra-claude"
+          ? (agent.name === "nccgs-adversarial-reviewer" ? "high" : "xhigh") : null;
+        assert.equal(text.match(/^effort:\s*(\S+)/m)?.[1] ?? null, expectedEffort, agent.name);
+      }
+    }
+    const file = path.join(temp, ".claude/agents/nccgs-adversarial-reviewer.md");
+    const before = fs.readFileSync(file, "utf8");
+    assert.equal(run("inherit", "--skip-path", ".claude/agents/nccgs-adversarial-reviewer.md").status, 0);
+    assert.equal(fs.readFileSync(file, "utf8"), before);
+    const invalid = run("unknown");
+    assert.notEqual(invalid.status, 0);
+    assert.equal(fs.readFileSync(file, "utf8"), before);
+    fs.writeFileSync(path.join(temp, ".claude/settings.json"), "invalid JSON");
+    assert.notEqual(run("astra-claude").status, 0);
+    assert.equal(fs.readFileSync(file, "utf8"), before);
+    const other = fs.readFileSync(path.join(temp, ".claude/agents/nccgs-unity-implementer.md"), "utf8");
+    assert.ok(!/^model:/m.test(other), "invalid settings must fail before rewriting agents");
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
 test("migrate-project defaults to a single full run", () => {
-  const skill = fs.readFileSync(path.join(root, ".claude/skills/migrate-project/SKILL.md"), "utf8");
+  const skill = fs.readFileSync(path.join(root, ".claude/skills/migrate-project/references/legacy.md"), "utf8");
   assert.match(skill, /Default to `full`/);
   assert.match(skill, /review, plan, apply, and verify in one invocation/i);
 });
@@ -42,7 +183,7 @@ test("model configurator can remove and restore model pins", () => {
     fs.copyFileSync(path.join(root, ".claude/nccgs/studio.json"), path.join(temp, ".claude/nccgs/studio.json"));
     fs.copyFileSync(path.join(root, ".claude/nccgs/tools/configure-models.mjs"), path.join(temp, ".claude/nccgs/tools/configure-models.mjs"));
     fs.writeFileSync(path.join(temp, ".nccgs/project.yaml"), "models:\n  profile: quality\n", "utf8");
-    for (const agent of studio.agents) fs.copyFileSync(path.join(root, ".claude/agents", `${agent.name}.md`), path.join(temp, ".claude/agents", `${agent.name}.md`));
+    copyAgentFixture(temp);
     const tool = path.join(temp, ".claude/nccgs/tools/configure-models.mjs");
     assert.equal(spawnSync(process.execPath, [tool, "--project", temp, "--profile", "inherit"]).status, 0);
     assert.ok(!/^model:/m.test(fs.readFileSync(path.join(temp, ".claude/agents", `${studio.agents[0].name}.md`), "utf8")));