@luizsantiago/spec-guardrails 3.1.11 → 3.2.1

package/README.md

@@ -11,7 +11,7 @@
 | **Solution** | One kit, two deliberate modes: **Process** (Node only) for a flexible spec-driven workflow; **Brakes** (Node + Python) for the **full product** — structural gates that exit non-zero when paperwork or evidence is missing. You approve specs/tasks in both. |
 | **Result** | Traceable `.specs/` memory, fewer fake finishes, cheaper turns (~70% less skill text on planning). Choose Process for light ceremony; add Python when you want the [Guarantees matrix](#guarantees-matrix) enforced automatically. |
 
-npm: [`@luizsantiago/spec-guardrails`](https://www.npmjs.com/package/@luizsantiago/spec-guardrails) **3.1.x**
+npm: [`@luizsantiago/spec-guardrails`](https://www.npmjs.com/package/@luizsantiago/spec-guardrails) **3.2.x**
 
 ---
 
@@ -41,11 +41,16 @@ npx @luizsantiago/spec-guardrails install
 
 Re-run `install` anytime to refresh skills; your `.specs/` decisions and `STATE.md` are kept.
 
-### Optional Atlas companions (Lego)
+### Governance focus (3.2+)
 
-Spec Guardrails is a **complete product alone**. Optional **Atlas** packages add domain specialization (Path Domains, catalogs). The first is [**Tech Atlas**](https://github.com/luizssantiago92/tech-atlas) (`@luizsantiago/tech-atlas`) — tech engineering context routing.
+Spec Guardrails is a **single product**: governance, evidence, verification, and controlled execution for agentic software development — not a bundle of companion packages.
 
-When paired, install Guardrails first, then the Atlas. Re-running Guardrails `install` **preserves** companion assets: Atlas skills/catalog, `.specs/atlas/`, mirrored `validate_layer_routing.py`, and `.specs/desks/` if present. Contract: [Companion: Tech Atlas](docs/guide/Companion-tech-atlas.md).
+| Capability | What it does |
+| --- | --- |
+| **Artifact gates** | Structural quality for spec, tasks, and cross-artifact consistency — with **blocking / warning / info** severity |
+| **Parallel waves** | `loop-plan` computes safe parallel groups; `workspace-prepare` isolates tasks in git worktrees |
+| **Execution policy** | Budgets, path scope, and escalation rules in `.specs/config.yaml` — consult via `execution-policy` |
+| **Independent verify** | Fresh-context verification with evidence-or-zero (`validate-state`) |
 
 | Need | Command |
 | --- | --- |
@@ -196,6 +201,7 @@ Full reference: **[Gates](docs/guide/gates.md)** · [Guarantees matrix](docs/gui
 | [Skills and hub](docs/guide/skills-and-hub.md) | What each skill file does |
 | [Gates](docs/guide/gates.md) | How each gate works |
 | [Platform parity](docs/guide/Platform-parity.md) | Shipped adapters (Cursor, Claude, Copilot, Codex) — core works with any agent |
+| [Restart PRD seed](docs/guide/Restart-prd-seed.md) | Clean-project PRD template for a single-package restart |
 | [FAQ](docs/guide/FAQ.md) | Common questions |
 | [Changelog](docs/CHANGELOG.md) | Full version history |
 
@@ -211,7 +217,8 @@ npx @luizsantiago/spec-guardrails install
 
 | Version | What you gain |
 | --- | --- |
-| **3.1.x** | Copilot/Codex/AGENTS.md adapters; doctor Process + Brakes scores; unified execution contracts; `validate-traceability` / `validate-quick`; `classify-change` / `feature-status` |
+| **3.2.x** | Single-package focus; artifact gate severity labels; git worktree isolation CLI; execution policy (budget/scope/escalation) |
+| **3.1.x** | Copilot/Codex/AGENTS.md adapters; doctor Process + Brakes scores; `validate-traceability` / `validate-quick`; `classify-change` / `feature-status` |
 | **3.0.x** | Final name Spec Guardrails; `.specs/guardrails/`; no dual-path ([Migration](docs/guide/Migration.md)) |
 | **2.2.x** | Seatbelt-era paths & markers; `doctor` Execute hints; docs split from README |
 | **2.1.x** | `loop-plan` + parallel `/loop` waves |

package/index.js

@@ -8,10 +8,26 @@ import { classifyChange, formatClassifyChange } from "./lib/classify-change.js";
 import { PACKAGE_VERSION, CLI_NAME } from "./lib/constants.js";
 import { phaseContext } from "./lib/config.js";
 import { doctor } from "./lib/doctor.js";
+import {
+  formatPolicyStatus,
+  loadExecutionPolicy,
+  loadPolicyState,
+  recordAgentRun,
+  recordTaskRetry,
+  resolvePathCheck,
+  savePolicyState,
+} from "./lib/execution-policy.js";
 import { featureInit } from "./lib/feature.js";
 import { featureStatus, formatFeatureStatus } from "./lib/feature-status.js";
 import { GATE_COMMANDS, AUX_COMMANDS, runGate, runGuardrailsScript } from "./lib/gates.js";
 import { install } from "./lib/install.js";
+import {
+  cleanupWorkspaces,
+  formatWorkspaceList,
+  formatWorkspaceResults,
+  listWorkspaces,
+  prepareWorkspaces,
+} from "./lib/workspace-isolation.js";
 import {
   initProjectConfig,
   listPresets,
@@ -50,10 +66,28 @@ Commands:
     [--json]                         Machine-readable output
   phase-context <phase>              Print .specs/config.yaml context + rules for a phase
   doctor [path]                      Audit guardrails readiness (score + next actions)
-                                      When Atlas companions are installed, also probes their
-                                      gates, rules, and PROJECT.md registry via INDEX.json
     [--json]                         Machine-readable output
     [--no-suggest]                   Hide per-check remediation hints
+  workspace-prepare <feature>        Create isolated git worktrees for parallel tasks
+    --tasks T1,T2                    Task ids to isolate (required)
+    [--base-ref HEAD]                Base ref for new worktrees
+    [--json]                         Machine-readable output
+  workspace-cleanup <feature>        Remove isolated worktrees for a feature
+    [--tasks T1,T2]                  Limit cleanup to specific tasks
+    [--force]                        Force-remove dirty worktrees (recovery after worker FAIL)
+    [--json]                         Machine-readable output
+  workspace-list <feature>           List isolated worktrees for a feature
+    [--json]                         Machine-readable output
+  execution-policy status            Show configured budgets, scope, and runtime counters
+    [--json]                         Machine-readable output
+  execution-policy check-path <path> Check whether a relative path is allowed by scope policy
+    [--json]                         Machine-readable output
+  execution-policy record-retry <task>  Increment retry counter for a task id (blocks at limit)
+  execution-policy record-run        Increment agent-run counter (blocks at budget)
+  memory-index rebuild               Rebuild SQLite memory index from .specs/ artifacts
+  memory-query --from <id>           Bounded context package from the knowledge graph
+    [--depth N]                      Traversal depth (default 2)
+    [--json]                         Machine-readable output
   validate-spec [spec.md|feature]    Closure gate for a feature spec
   analyze-artifacts [feature]        Cross-artifact consistency before task approval
   validate-tasks [tasks.md|feature]  Granularity gate for a task breakdown
@@ -63,7 +97,7 @@ Commands:
   validate-quick [quick-folder]      Quick-mode TASK.md / SUMMARY.md structural gate
   validate-state [feature]           Completion gate before declaring a feature done
   check-commit --message "<msg>"     Conventional Commits gate
-  lessons <add|list|penalize|prune|status>  Lessons engine
+  lessons <add|list|penalize|prune|promote|graduate|status>  Lessons engine
   --help                             Show this message
   --version                          Print the package version
 `;
@@ -323,6 +357,192 @@ if (command === "--version" || command === "-v" || command === "version") {
     console.error(`❌ ${err.message}`);
     process.exit(1);
   }
+} else if (command === "workspace-prepare") {
+  try {
+    let json = false;
+    let baseRef = "HEAD";
+    let tasksRaw = "";
+    const positional = [];
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--json") {
+        json = true;
+      } else if (arg === "--base-ref") {
+        baseRef = args[++i];
+        if (!baseRef) {
+          throw new Error("--base-ref requires a git ref");
+        }
+      } else if (arg === "--tasks") {
+        tasksRaw = args[++i] ?? "";
+        if (!tasksRaw) {
+          throw new Error("--tasks requires a comma-separated list (e.g. T1,T2)");
+        }
+      } else {
+        positional.push(arg);
+      }
+    }
+
+    const featureId = positional[0];
+    if (!featureId) {
+      throw new Error("Usage: workspace-prepare <feature> --tasks T1,T2");
+    }
+
+    const taskIds = tasksRaw.split(",").map((item) => item.trim()).filter(Boolean);
+    const results = await prepareWorkspaces(process.cwd(), { featureId, taskIds, baseRef });
+    process.stdout.write(formatWorkspaceResults(results, { json }));
+
+    if (results.some((item) => item.status === "failed")) {
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+} else if (command === "workspace-cleanup") {
+  try {
+    let json = false;
+    let force = false;
+    let tasksRaw = "";
+    const positional = [];
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--json") {
+        json = true;
+      } else if (arg === "--force") {
+        force = true;
+      } else if (arg === "--tasks") {
+        tasksRaw = args[++i] ?? "";
+      } else {
+        positional.push(arg);
+      }
+    }
+
+    const featureId = positional[0];
+    if (!featureId) {
+      throw new Error("Usage: workspace-cleanup <feature> [--tasks T1,T2] [--force]");
+    }
+
+    const taskIds = tasksRaw
+      ? tasksRaw.split(",").map((item) => item.trim()).filter(Boolean)
+      : undefined;
+    const results = await cleanupWorkspaces(process.cwd(), { featureId, taskIds, force });
+    process.stdout.write(formatWorkspaceResults(results, { json }));
+
+    if (results.some((item) => item.status === "failed")) {
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+} else if (command === "workspace-list") {
+  try {
+    let json = false;
+    const positional = [];
+
+    for (const arg of args) {
+      if (arg === "--json") {
+        json = true;
+      } else {
+        positional.push(arg);
+      }
+    }
+
+    const featureId = positional[0];
+    if (!featureId) {
+      throw new Error("Usage: workspace-list <feature> [--json]");
+    }
+
+    const workspaces = await listWorkspaces(process.cwd(), featureId);
+    process.stdout.write(formatWorkspaceList(workspaces, { json, featureId }));
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+} else if (command === "execution-policy") {
+  try {
+    const sub = args[0];
+    let json = false;
+    const rest = [];
+
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--json") {
+        json = true;
+      } else {
+        rest.push(args[i]);
+      }
+    }
+
+    const cwd = process.cwd();
+    const policy = await loadExecutionPolicy(cwd);
+    const state = await loadPolicyState(cwd);
+
+    if (sub === "status") {
+      process.stdout.write(formatPolicyStatus(policy, state, { json }));
+    } else if (sub === "check-path") {
+      const relativePath = rest[0];
+      if (!relativePath) {
+        throw new Error("Usage: execution-policy check-path <relative-path>");
+      }
+      const result = resolvePathCheck(relativePath, policy);
+      if (json) {
+        console.log(JSON.stringify({ path: relativePath, ...result }, null, 2));
+      } else {
+        const label = result.allowed
+          ? "allowed"
+          : result.severity === "warning"
+            ? "blocked (warn)"
+            : "blocked";
+        console.log(`${relativePath}: ${label} (${result.reason})`);
+      }
+      if (result.exitCode !== 0) {
+        process.exit(result.exitCode);
+      }
+    } else if (sub === "record-retry") {
+      const taskId = rest[0];
+      if (!taskId) {
+        throw new Error("Usage: execution-policy record-retry <task-id>");
+      }
+      const recorded = recordTaskRetry(state, taskId, policy);
+      if (!recorded.ok) {
+        console.error(`❌ ${recorded.message}`);
+        process.exit(1);
+      }
+      await savePolicyState(cwd, recorded.state);
+      if (json) {
+        console.log(
+          JSON.stringify({ taskId, retries: recorded.retries, state: recorded.state }, null, 2),
+        );
+      } else {
+        console.log(`Recorded retry for ${taskId}: ${recorded.retries}`);
+      }
+    } else if (sub === "record-run") {
+      const recorded = recordAgentRun(state, policy);
+      if (!recorded.ok) {
+        console.error(`❌ ${recorded.message}`);
+        process.exit(1);
+      }
+      await savePolicyState(cwd, recorded.state);
+      if (json) {
+        console.log(
+          JSON.stringify({ agent_runs: recorded.state.agent_runs, state: recorded.state }, null, 2),
+        );
+      } else {
+        console.log(
+          `Recorded agent run: ${recorded.state.agent_runs}/${policy.budget.max_agent_runs}`,
+        );
+      }
+    } else {
+      throw new Error(
+        "Usage: execution-policy status | check-path <path> | record-retry <task> | record-run",
+      );
+    }
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
 } else if (command === "classify-change") {
   try {
     let json = false;
@@ -375,7 +595,8 @@ if (command === "--version" || command === "-v" || command === "version") {
     console.error(`❌ ${err.message}`);
     process.exit(1);
   }
-} else if (AUX_COMMANDS.includes(command)) {  try {
+} else if (AUX_COMMANDS.includes(command)) {
+  try {
     const code = await runGuardrailsScript(command, args);
     process.exit(code);
   } catch (err) {

package/lib/adapter-registry.js

@@ -0,0 +1,128 @@
+import { injectAgentsMd } from "./agents-md.js";
+import { injectCodexAgents } from "./codex-agents.js";
+import { injectCopilotInstructions } from "./copilot-instructions.js";
+import { injectClaudeMd } from "./claude-md.js";
+import { injectCursorRules } from "./cursorrules.js";
+
+/**
+ * @typedef {{
+ *   id: string,
+ *   label: string,
+ *   skillsDir: string | null,
+ *   entryFiles: string[],
+ *   capabilities: {
+ *     supports_hooks: boolean,
+ *     supports_commands: boolean,
+ *     supports_rules: boolean,
+ *     supports_skills: boolean,
+ *   },
+ *   install: (cwd: string) => Promise<void>,
+ * }} PlatformAdapter
+ */
+
+/** @type {PlatformAdapter[]} */
+export const ADAPTER_REGISTRY = [
+  {
+    id: "cursor",
+    label: "Cursor",
+    skillsDir: ".cursor/skills",
+    entryFiles: [".cursorrules", ".cursor/rules/engineering-baseline.mdc"],
+    capabilities: {
+      supports_hooks: true,
+      supports_commands: true,
+      supports_rules: true,
+      supports_skills: true,
+    },
+    install: injectCursorRules,
+  },
+  {
+    id: "claude",
+    label: "Claude Code",
+    skillsDir: ".claude/skills",
+    entryFiles: [".claude/CLAUDE.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: true,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectClaudeMd,
+  },
+  {
+    id: "copilot",
+    label: "GitHub Copilot",
+    skillsDir: ".github/skills",
+    entryFiles: [".github/copilot-instructions.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectCopilotInstructions,
+  },
+  {
+    id: "codex",
+    label: "OpenAI Codex",
+    skillsDir: ".codex/skills",
+    entryFiles: [".codex/AGENTS.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: true,
+    },
+    install: injectCodexAgents,
+  },
+  {
+    id: "agents-md",
+    label: "AGENTS.md (open standard)",
+    skillsDir: null,
+    entryFiles: ["AGENTS.md"],
+    capabilities: {
+      supports_hooks: false,
+      supports_commands: false,
+      supports_rules: false,
+      supports_skills: false,
+    },
+    install: injectAgentsMd,
+  },
+];
+
+/**
+ * @param {string} id
+ * @returns {PlatformAdapter | undefined}
+ */
+export function getAdapter(id) {
+  return ADAPTER_REGISTRY.find((adapter) => adapter.id === id);
+}
+
+/** @returns {PlatformAdapter[]} */
+export function listAdapters() {
+  return [...ADAPTER_REGISTRY];
+}
+
+/**
+ * @param {keyof PlatformAdapter["capabilities"]} capability
+ * @returns {PlatformAdapter[]}
+ */
+export function getAdaptersWithCapability(capability) {
+  return ADAPTER_REGISTRY.filter((adapter) => adapter.capabilities[capability]);
+}
+
+/**
+ * @param {string} cwd
+ * @param {PlatformAdapter} [adapter]
+ */
+export async function installAdapter(cwd, adapter) {
+  await adapter.install(cwd);
+}
+
+/**
+ * Install all registered platform adapters.
+ *
+ * @param {string} cwd
+ */
+export async function installAllAdapters(cwd) {
+  await Promise.all(ADAPTER_REGISTRY.map((adapter) => installAdapter(cwd, adapter)));
+}

package/lib/adapters.js

@@ -1,17 +1,11 @@
-import { injectAgentsMd } from "./agents-md.js";
-import { injectCodexAgents } from "./codex-agents.js";
-import { injectCopilotInstructions } from "./copilot-instructions.js";
+import { installAllAdapters } from "./adapter-registry.js";
 
 /**
  * Install shipped platform adapter entry files (Copilot, Codex, AGENTS.md).
- * Cursor and Claude adapters are injected separately in install.js.
+ * Cursor and Claude adapters are injected via the same registry during install.
  *
  * @param {string} cwd
  */
 export async function installPlatformAdapters(cwd) {
-  return Promise.all([
-    injectCopilotInstructions(cwd),
-    injectAgentsMd(cwd),
-    injectCodexAgents(cwd),
-  ]);
+  return installAllAdapters(cwd);
 }

package/lib/archive.js

@@ -9,6 +9,7 @@ import {
 import { ensureDir, readFileSafe, writeFileSafe } from "./fs-utils.js";
 import { runGate } from "./gates.js";
 import { assertSafeDomainSlug } from "./slug-utils.js";
+import { isPassVerdict } from "./validation-verdict.js";
 import {
   featureDir,
   readFeatureArtifact,
@@ -23,15 +24,6 @@ Track milestones and archived features.
 
 `;
 
-/**
- * @param {string} text
- * @returns {boolean}
- */
-function validationPassed(text) {
-  const visible = text.replace(/<!--[\s\S]*?-->/g, "");
-  return /\b(?:PASS|PASSED)\b/.test(visible);
-}
-
 /**
  * @param {string} cwd
  * @param {string} featureId
@@ -150,7 +142,7 @@ export async function archiveFeature(featureArg, options = {}) {
       },
     );
 
-    if (!validationPassed(validationText)) {
+    if (!isPassVerdict(validationText)) {
       throw new Error(
         `validation.md for ${featureId} does not contain PASS/PASSED. Run validate-state first.`,
       );

package/lib/assets.js

@@ -55,8 +55,9 @@ export function resolveInstallSource(repoUrl) {
 /**
  * @param {string} remotePath
  * @param {string} destPath
+ * @param {{ boundary?: string }} [options]
  */
-export async function copyPackagedAsset(remotePath, destPath) {
+export async function copyPackagedAsset(remotePath, destPath, options = {}) {
   const source = packagedAssetPath(remotePath);
 
   try {
@@ -71,7 +72,7 @@ export async function copyPackagedAsset(remotePath, destPath) {
     throw err;
   }
 
-  await assertSafeWriteTarget(destPath);
+  await assertSafeWriteTarget(destPath, options);
 
   try {
     await fs.copyFile(source, destPath);
@@ -91,7 +92,7 @@ export async function copyPackagedAsset(remotePath, destPath) {
  * repo with no override (kept for the remote path; the default install no
  * longer uses it).
  *
- * @param {{ remotePath: string, destPath: string, repoUrl?: string, state: { warned: boolean }, log: (msg: string) => void }} params
+ * @param {{ remotePath: string, destPath: string, repoUrl?: string, state: { warned: boolean }, log: (msg: string) => void, boundary?: string }} params
  */
 export async function downloadRemoteAsset({
   remotePath,
@@ -99,9 +100,10 @@ export async function downloadRemoteAsset({
   repoUrl,
   state,
   log,
+  boundary,
 }) {
   try {
-    await downloadToFile(resolveAssetUrl(remotePath, repoUrl), destPath);
+    await downloadToFile(resolveAssetUrl(remotePath, repoUrl), destPath, { boundary });
     return;
   } catch (err) {
     const missingPinnedAsset =
@@ -123,15 +125,16 @@ export async function downloadRemoteAsset({
   await downloadToFile(
     resolveAssetUrl(remotePath, FALLBACK_REPO_URL),
     destPath,
+    { boundary },
   );
 }
 
 /**
- * @param {{ remotePath: string, destPath: string, source: ReturnType<typeof resolveInstallSource>, state: { warned: boolean }, log: (msg: string) => void }} params
+ * @param {{ remotePath: string, destPath: string, source: ReturnType<typeof resolveInstallSource>, state: { warned: boolean }, log: (msg: string) => void, boundary?: string }} params
  */
-export async function installAsset({ remotePath, destPath, source, state, log }) {
+export async function installAsset({ remotePath, destPath, source, state, log, boundary }) {
   if (source.mode === "package") {
-    await copyPackagedAsset(remotePath, destPath);
+    await copyPackagedAsset(remotePath, destPath, { boundary });
     return;
   }
 
@@ -141,5 +144,6 @@ export async function installAsset({ remotePath, destPath, source, state, log })
     repoUrl: source.repoUrl,
     state,
     log,
+    boundary,
   });
 }

package/lib/constants.js

@@ -108,6 +108,8 @@ export const SCRIPT_ASSETS = [
   { file: "check_commit.py", remotePath: "scripts/check_commit.py" },
   { file: "lessons.py", remotePath: "scripts/lessons.py" },
   { file: "loop_plan.py", remotePath: "scripts/loop_plan.py" },
+  { file: "memory_index.py", remotePath: "scripts/memory_index.py" },
+  { file: "memory_query.py", remotePath: "scripts/memory_query.py" },
 ];
 
 /** @type {{ file: string, remotePath: string }[]} */

package/lib/doctor.js

@@ -8,11 +8,6 @@ import {
   NPX,
   SKILL_DIRS,
 } from "./constants.js";
-import { listInstalledCompanions } from "./companions.js";
-import {
-  runCompanionDoctorChecks,
-  summarizeCompanionChecks,
-} from "./companion-doctor.js";
 import { resolvePython, resolveScriptsDir } from "./gates.js";
 import { readFileSafe } from "./fs-utils.js";
 import { listFeatureIds, readActiveFeatureFromState } from "./specs-utils.js";
@@ -203,21 +198,6 @@ export async function runDoctorChecks(cwd) {
     suggest: NPX("project-init"),
   });
 
-  const companionReport = await runCompanionDoctorChecks(cwd);
-  if (companionReport.checks.length > 0) {
-    checks.push(...companionReport.checks);
-  } else {
-    checks.push({
-      id: "atlas-companions",
-      label: "Atlas companions registry (.specs/companions/INDEX.json)",
-      weight: 5,
-      pass: false,
-      optional: true,
-      suggest:
-        "Optional: npx @luizsantiago/tech-atlas install (or another Atlas package)",
-    });
-  }
-
   const activeFeature = await readActiveFeature(cwd);
   let activeFeatureOk = true;
   let activeFeatureSuggest;
@@ -399,45 +379,16 @@ export async function doctor(cwd, options = {}) {
   const executeHint = await resolveExecuteHint(cwd, activeFeature);
   const pythonCheck = checks.find((check) => check.id === "python");
   const pythonMissing = pythonCheck ? !pythonCheck.pass : false;
-  const companions = await listInstalledCompanions(cwd);
-  const companionChecks = checks.filter((check) => check.id.startsWith("atlas-"));
-  const companionSummary = summarizeCompanionChecks(companionChecks);
-  const stackPaired = companions.length > 0 && companionChecks.some((c) => !c.optional);
 
   if (options.json) {
     console.log(
       JSON.stringify(
-        {
-          score,
-          modes,
-          checks,
-          suggestions,
-          executeHint,
-          pythonMissing,
-          stack: {
-            paired: stackPaired,
-            companions: companions.map((c) => ({
-              id: c.id,
-              npm: c.npm,
-              version: c.version,
-              displayName: c.displayName,
-            })),
-            atlasReady: companionSummary.ready,
-          },
-        },
+        { score, modes, checks, suggestions, executeHint, pythonMissing },
         null,
         2,
       ),
     );
-    return {
-      score,
-      modes,
-      checks,
-      suggestions,
-      executeHint,
-      pythonMissing,
-      stack: { paired: stackPaired, companions, atlasReady: companionSummary.ready },
-    };
+    return { score, modes, checks, suggestions, executeHint, pythonMissing };
   }
 
   if (pythonMissing) {
@@ -456,13 +407,6 @@ export async function doctor(cwd, options = {}) {
   console.log(`  Brakes:  ${modes.brakes.score}/100${brakesHint}\n`);
   console.log(`Guardrails Ready: ${score}/100\n`);
 
-  if (companions.length > 0) {
-    const stackLabel = stackPaired ? "paired Lego stack" : "solo + Atlas companions";
-    console.log(
-      `Atlas stack: ${stackLabel} — ${companions.length} companion(s), ${companionSummary.passed}/${companionSummary.total} checks passed\n`,
-    );
-  }
-
   for (const check of checks) {
     const mark = check.pass ? "✓" : "✗";
     const optional = check.optional ? " (optional)" : "";
@@ -483,13 +427,5 @@ export async function doctor(cwd, options = {}) {
     console.log(`\nExecute hint:\n  → ${executeHint}`);
   }
 
-  return {
-    score,
-    modes,
-    checks,
-    suggestions,
-    executeHint,
-    pythonMissing,
-    stack: { paired: stackPaired, companions, atlasReady: companionSummary.ready },
-  };
+  return { score, modes, checks, suggestions, executeHint, pythonMissing };
 }