mason-context 0.15.0 → 0.16.1

package/dist/mason-auto.js

@@ -2521,7 +2521,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec7 = promisify8(execFile8);
-    engineVersion = true ? "0.15.0" : "development";
+    engineVersion = true ? "0.16.1" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
@@ -2813,9 +2813,9 @@ async function automationStatus(dir) {
   if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) throw new Error("Automation state belongs to another workspace.");
   const inputs = await readInputs(ws.root);
   const latest = state.latest ? await readStoreJson(ws.root, state.latest) : null;
-  const hosts = {};
+  const hosts2 = {};
   for (const session of Object.values(state.sessions)) {
-    const host = hosts[session.host] ??= { sessions: 0, observedEvents: [] };
+    const host = hosts2[session.host] ??= { sessions: 0, observedEvents: [] };
     host.sessions++;
     host.observedEvents = [.../* @__PURE__ */ new Set([...host.observedEvents, ...Object.keys(session.events)])];
   }
@@ -2828,7 +2828,7 @@ async function automationStatus(dir) {
     baselinePaths: state.baselines.map((b) => b.path),
     reportPath: state.latest,
     verificationStatus: unfinished ? "unavailable" : latest?.status ?? "unavailable",
-    hosts,
+    hosts: hosts2,
     execution,
     note: "Observed events do not prove all tool paths are intercepted. Run check to verify the retained evidence."
   };
@@ -2920,7 +2920,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.15.0" : "development";
+    executingVersion = () => true ? "0.16.1" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -3124,7 +3124,13 @@ function managedBlock(text2, start, end, body) {
 async function applyEdit(root, edit) {
   const current = await readText(root, edit.path);
   if (current === edit.after) return false;
-  if (current !== edit.before) throw new Error("Setup input changed during installation: " + edit.path + ". Rerun setup to resume.");
+  if (current !== edit.before) throw new Error("Integration input changed during update: " + edit.path + ". Rerun the requested command to resume.");
+  if (edit.after === null) {
+    const file2 = await storePath(root, edit.path);
+    if (await readText(root, edit.path) !== edit.before) throw new Error("Input changed during removal: " + edit.path);
+    await fs14.unlink(file2);
+    return true;
+  }
   const file = await storePath(root, edit.path, true);
   const temporary = path18.join(path18.dirname(file), ".mason-setup-" + randomUUID5() + ".tmp");
   try {
@@ -3136,7 +3142,7 @@ async function applyEdit(root, edit) {
     } finally {
       await handle.close();
     }
-    if (await readText(root, edit.path) !== edit.before) throw new Error("Setup input changed during installation: " + edit.path);
+    if (await readText(root, edit.path) !== edit.before) throw new Error("Integration input changed during update: " + edit.path);
     await fs14.rename(temporary, file);
     return true;
   } finally {
@@ -3151,27 +3157,100 @@ var init_files2 = __esm({
   }
 });
 
-// src/mcp/init.ts
+// src/setup/ownership.ts
+var ownership_exports = {};
+__export(ownership_exports, {
+  BLOCKS: () => BLOCKS,
+  OWNERSHIP_PATH: () => OWNERSHIP_PATH,
+  blockSpan: () => blockSpan,
+  completedHookOwnership: () => completedHookOwnership,
+  ownershipEdit: () => ownershipEdit,
+  ownershipSchema: () => ownershipSchema
+});
 import { z as z10 } from "zod";
+import { parse } from "smol-toml";
+function blockSpan(text2, start, end) {
+  const starts = text2.split(start).length - 1, ends = text2.split(end).length - 1;
+  if (!starts && !ends) return null;
+  const from = text2.indexOf(start), to = text2.indexOf(end) + end.length;
+  if (starts !== 1 || ends !== 1 || to <= from) throw new Error("Ambiguous Mason markers; inspect the marked block manually.");
+  return { from, to, text: text2.slice(from, to) };
+}
+async function ownershipEdit(root, edits, hookCommands = {}) {
+  const before = await readText(root, OWNERSHIP_PATH);
+  const record = before === null ? { version: 1, files: {} } : ownershipSchema.parse(JSON.parse(before));
+  for (const edit of edits) {
+    const previous = record.files[edit.path];
+    const entry = {
+      created: edit.before === null || (previous?.created ?? false),
+      initialHash: edit.before === null || previous?.initialHash === hash(edit.before) ? hash(edit.after) : previous?.initialHash ?? hash(edit.after),
+      blocks: Object.fromEntries(BLOCKS.flatMap(([start, end]) => {
+        const block = blockSpan(edit.after, start, end);
+        return block ? [[start, hash(block.text)]] : [];
+      }))
+    };
+    const mcp = edit.path === ".codex/config.toml" ? parse(edit.after).mcp_servers?.mason : edit.path === ".mcp.json" ? JSON.parse(edit.after).mcpServers?.mason : void 0;
+    const hooks = edit.path === ".codex/hooks.json" || edit.path === ".claude/settings.json" ? JSON.parse(edit.after).hooks : void 0;
+    record.files[edit.path] = {
+      ...entry,
+      ...mcp === void 0 ? {} : { mcpHash: hash(mcp) },
+      ...hookCommands[edit.path] ? { hookCommands: [.../* @__PURE__ */ new Set([...previous?.hookCommands ?? [], hookCommands[edit.path]])] } : {},
+      ...hooks === void 0 ? {} : { hooks: Object.fromEntries(Object.entries(hooks).map(([event, groups]) => [event, groups.flatMap((group) => group.hooks.map(hash))])) }
+    };
+  }
+  return { path: OWNERSHIP_PATH, before, after: JSON.stringify(record, null, 2) + "\n" };
+}
+async function completedHookOwnership(root, file, command) {
+  const before = await readText(root, OWNERSHIP_PATH);
+  const record = ownershipSchema.parse(JSON.parse(before ?? "null"));
+  record.files[file].hookCommands = [command];
+  return { path: OWNERSHIP_PATH, before, after: JSON.stringify(record, null, 2) + "\n" };
+}
+var OWNERSHIP_PATH, BLOCKS, fileSchema, ownershipSchema;
+var init_ownership = __esm({
+  "src/setup/ownership.ts"() {
+    "use strict";
+    init_evidence();
+    init_files2();
+    OWNERSHIP_PATH = ".mason/local/integration.json";
+    BLOCKS = [
+      ["<!-- mason:start -->", "<!-- mason:end -->"],
+      ["<!-- mason:agents:start -->", "<!-- mason:agents:end -->"],
+      ["# mason:mcp:start", "# mason:mcp:end"]
+    ];
+    fileSchema = z10.object({
+      created: z10.boolean(),
+      initialHash: z10.string(),
+      blocks: z10.record(z10.string()),
+      mcpHash: z10.string().optional(),
+      hookCommands: z10.array(z10.string()).optional(),
+      hooks: z10.record(z10.array(z10.string())).optional()
+    });
+    ownershipSchema = z10.object({ version: z10.literal(1), files: z10.record(fileSchema) });
+  }
+});
+
+// src/mcp/init.ts
+import { z as z11 } from "zod";
 var markerSchema, CLAUDE_MD_SECTION, ASSISTANT_SETUP, QUICKSTART_PLAYBOOK, MAP_PLAYBOOK;
 var init_init = __esm({
   "src/mcp/init.ts"() {
     "use strict";
     init_storage();
     init_files2();
-    markerSchema = z10.object({
-      version: z10.literal(1),
-      initializedAt: z10.string(),
-      features: z10.object({ confluence: z10.boolean().optional() }).passthrough().optional()
+    markerSchema = z11.object({
+      version: z11.literal(1),
+      initializedAt: z11.string(),
+      features: z11.object({ confluence: z11.boolean().optional() }).passthrough().optional()
     }).passthrough();
     CLAUDE_MD_SECTION = `<!-- mason:start -->
 ## Mason project knowledge
 
 Mason provides recorded decisions and file impact over MCP. A concept map is optional.
 
-- Task, bug, or change request \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
+- Task, bug, change request, or investigation of why the project works this way \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
 - Before editing a file \u2192 \`get_impact\` to check references, tests, and historical change partners.
-- Learned something the code cannot explain (a failed approach, an incident's cause, a workaround's reason, a review-settled convention) \u2192 \`save_decision\` with rationale, anchors, and any known owner, sources, and recorder. It creates a proposal immediately without setup or a map. Never invent attribution or record code-derivable facts, session trivia, or secrets.
+- Investigation or correction reveals a reusable project lesson \u2192 \`save_decision\` before finishing. Capture only the lasting constraint and reason, with anchors and known sources, owner, and recorder. This creates a proposal; never infer approval. Preserve uncertain causes and unknown attribution. Route project lessons here; keep personal preferences in agent memory. Skip code summaries, current checkout status, temporary task permissions, session trivia, and secrets. No qualifying lesson means no record.
 - Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
 - Asked to review or re-verify a decision \u2192 \`review_decision\` first to inspect content, sources, history, and code changes. Record acceptance, reaffirmation, or retirement only when authorized by the user or a cited team review, with the actual reviewer and reason. Never infer approval from unchanged code. Review and commit the local record through the normal project workflow.
 - For an architectural overview, use \`get_snapshot\` if a map is available. If \`map.status\` is missing or invalid, use available decisions and source evidence; do not start building a map unless requested.
@@ -3268,8 +3347,8 @@ __export(config_exports, {
   mcpPath: () => mcpPath
 });
 import { isDeepStrictEqual } from "util";
-import { parse, stringify } from "smol-toml";
-import { z as z11 } from "zod";
+import { parse as parse2, stringify } from "smol-toml";
+import { z as z12 } from "zod";
 async function instructionEdits(root, host) {
   const found = await Promise.all(DOC_CANDIDATES.map(async (file) => ({ path: file, text: await readText(root, file) })));
   const existing = found.find((f) => f.text !== null);
@@ -3310,7 +3389,7 @@ async function mcpEdit(root, host) {
     const servers2 = object.parse(config2.mcpServers ?? {});
     return { path: file, before, after: JSON.stringify({ ...config2, mcpServers: { ...servers2, mason: managedMcp(servers2.mason, host) } }, null, 2) + "\n" };
   }
-  const config = parse(before ?? "");
+  const config = parse2(before ?? "");
   const managed = (before ?? "").includes(TOML_START);
   const servers = config.mcp_servers;
   const desired = managedMcp(servers?.mason, host);
@@ -3322,7 +3401,7 @@ async function mcpEdit(root, host) {
     for (const span of spans.reverse()) base = base.slice(0, span.start) + base.slice(span.end);
   }
   const after = managedBlock(base, TOML_START, TOML_END, stringify({ mcp_servers: { mason: desired } }).trimEnd());
-  const parsed = parse(after);
+  const parsed = parse2(after);
   const expected = { ...config, mcp_servers: { ...servers ?? {}, mason: desired } };
   if (!isDeepStrictEqual(parsed, expected)) throw new Error("Could not safely configure the Mason MCP entry without changing other settings.");
   return { path: file, before, after };
@@ -3360,7 +3439,7 @@ async function ancillaryEdits(root) {
 }
 async function inspectHostConfig(root, host, plannedMcp) {
   const text2 = plannedMcp ?? await readText(root, mcpPath(host));
-  const config = host === "codex" ? parse(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
+  const config = host === "codex" ? parse2(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
   const servers = host === "codex" ? config.mcp_servers : config.mcpServers;
   const hooks = automationConfigSchema.parse(JSON.parse(await readText(root, configPath(host)) ?? "{}"));
   const expected = hookConfig(host, hookCommand(host));
@@ -3385,7 +3464,7 @@ var init_config = __esm({
     init_install();
     init_files2();
     init_launcher();
-    object = z11.record(z11.unknown());
+    object = z12.record(z12.unknown());
     mcpPath = (host) => host === "codex" ? ".codex/config.toml" : ".mcp.json";
     TOML_START = "# mason:mcp:start";
     TOML_END = "# mason:mcp:end";
@@ -3402,24 +3481,28 @@ __export(install_exports, {
   configPath: () => configPath,
   installAutomation: () => installAutomation,
   installedAutomation: () => installedAutomation,
-  planAutomationInstall: () => planAutomationInstall
+  planAutomationInstall: () => planAutomationInstall,
+  recordSchema: () => recordSchema
 });
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 async function installationRecord(root) {
   return recordSchema.parse(await readStoreJson(root, AUTOMATION_PATH) ?? { version: 1, hosts: {} });
 }
 async function installAutomation(dir, host, command) {
   const ws = await workspace(dir);
-  return withLock(ws.root, ".mason/reports/automation-install", () => installLocked(ws.root, host, command));
+  return withLock(ws.root, ".mason/reports/setup-lock", () => installLocked(ws.root, host, command));
 }
 async function planAutomationInstall(root, host, command) {
   const file = configPath(host);
-  const existing = automationConfigSchema.parse(await readStoreJson(root, file) ?? {});
+  const before = await readText(root, file);
+  const existing = automationConfigSchema.parse(JSON.parse(before ?? "{}"));
   const record = await installationRecord(root);
   const desired = hookConfig(host, command);
   const newCommand = desired.hooks.SessionStart[0].hooks[0].command;
   const previous = record.hosts[host]?.command;
-  const owned = /* @__PURE__ */ new Set([previous, newCommand]);
+  const ownershipText = await readText(root, OWNERSHIP_PATH);
+  const pending = ownershipText === null ? [] : ownershipSchema.parse(JSON.parse(ownershipText)).files[file]?.hookCommands ?? [];
+  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand]);
   const hooks = existing.hooks ?? {};
   for (const event of HOOK_EVENTS) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
@@ -3429,15 +3512,20 @@ async function planAutomationInstall(root, host, command) {
     hooks[event].push(...desired.hooks[event]);
   }
   record.hosts[host] = { command: newCommand };
-  return { file, config: { ...existing, hooks }, record, newCommand };
+  return { file, before, config: { ...existing, hooks }, record, newCommand };
 }
 async function installLocked(root, host, command) {
-  const { file, config, record, newCommand } = await planAutomationInstall(root, host, command);
+  const { file, before, config, record, newCommand } = await planAutomationInstall(root, host, command);
   const { ancillaryEdits: ancillaryEdits2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const { applyEdit: applyEdit2 } = await Promise.resolve().then(() => (init_files2(), files_exports));
-  for (const edit of await ancillaryEdits2(root)) await applyEdit2(root, edit);
-  await writeStoreJson(root, file, config);
+  const { ownershipEdit: ownershipEdit2, completedHookOwnership: completedHookOwnership2 } = await Promise.resolve().then(() => (init_ownership(), ownership_exports));
+  const edit = { path: file, before, after: JSON.stringify(config, null, 2) + "\n" };
+  const ancillary = await ancillaryEdits2(root);
+  await applyEdit2(root, await ownershipEdit2(root, [edit], { [file]: newCommand }));
+  for (const edit2 of ancillary) await applyEdit2(root, edit2);
+  await applyEdit2(root, edit);
   await writeStoreJson(root, AUTOMATION_PATH, record);
+  await applyEdit2(root, await completedHookOwnership2(root, file, newCommand));
   return {
     version: 1,
     host,
@@ -3475,14 +3563,248 @@ var init_install = __esm({
     init_evidence();
     init_adapters();
     init_store();
-    groupSchema = z12.object({ hooks: z12.array(z12.object({ type: z12.string(), command: z12.string().optional() }).passthrough()) }).passthrough();
-    automationConfigSchema = z12.object({ hooks: z12.record(z12.array(groupSchema)).optional() }).passthrough();
-    recordSchema = z12.object({ version: z12.literal(1), hosts: z12.record(z12.object({ command: z12.string() })) });
+    init_files2();
+    init_ownership();
+    groupSchema = z13.object({ hooks: z13.array(z13.object({ type: z13.string(), command: z13.string().optional() }).passthrough()) }).passthrough();
+    automationConfigSchema = z13.object({ hooks: z13.record(z13.array(groupSchema)).optional() }).passthrough();
+    recordSchema = z13.object({ version: z13.literal(1), hosts: z13.record(z13.object({ command: z13.string() })) });
     AUTOMATION_PATH = ".mason/local/automation.json";
     configPath = (host) => host === "claude" ? ".claude/settings.json" : ".codex/hooks.json";
   }
 });
 
+// src/setup/teardown.ts
+var teardown_exports = {};
+__export(teardown_exports, {
+  summarizeTeardown: () => summarizeTeardown,
+  teardownProject: () => teardownProject
+});
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { parse as parse3, stringify as stringify2 } from "smol-toml";
+import fg5 from "fast-glob";
+import { z as z14 } from "zod";
+async function planTeardown(root, selected) {
+  const edits = [], diagnostics = [];
+  const inputs = /* @__PURE__ */ new Map();
+  const read = async (file) => {
+    if (!inputs.has(file)) inputs.set(file, await readText(root, file));
+    return inputs.get(file);
+  };
+  const attempt = async (file, action) => {
+    try {
+      await action();
+    } catch (error) {
+      diagnostics.push({ path: file, message: error instanceof Error ? error.message : String(error) });
+    }
+  };
+  const ownershipBefore = await read(OWNERSHIP_PATH);
+  const ownership = ownershipBefore === null ? { version: 1, files: {} } : ownershipSchema.parse(JSON.parse(ownershipBefore));
+  const setupBefore = await read(SETUP_PATH);
+  const setup = setupBefore === null ? null : setupSchema.parse(JSON.parse(setupBefore));
+  const automationBefore = await read(AUTOMATION_PATH);
+  const automation = automationBefore === null ? null : recordSchema.parse(JSON.parse(automationBefore));
+  const commands = (host) => new Set([
+    automation?.hosts[host]?.command,
+    ...ownership.files[configPath(host)]?.hookCommands ?? [],
+    hookConfig(host, hookCommand(host)).hooks.SessionStart[0].hooks[0].command,
+    hookConfig(host).hooks.SessionStart[0].hooks[0].command
+  ].filter((command) => !!command));
+  const possibleHook = (command, host) => commands(host).has(command) || /\bmason(?:-auto|-hook)?\b/.test(command);
+  const add = (file, before, after, empty) => {
+    edits.push({ path: file, before, after: ownership.files[file]?.created && (empty || ownership.files[file].initialHash === hash(before)) ? null : after });
+  };
+  let remainingHost = hosts.some((host) => !selected.includes(host) && (setup?.hosts[host] || automation?.hosts[host] || ownership.files[mcpPath(host)] || ownership.files[configPath(host)]));
+  for (const host of hosts.filter((host2) => !selected.includes(host2))) {
+    await attempt(mcpPath(host), async () => {
+      const text2 = await read(mcpPath(host));
+      const config = host === "codex" ? parse3(text2 ?? "") : object2.parse(JSON.parse(text2 ?? "{}"));
+      const servers = object2.parse((host === "codex" ? config.mcp_servers : config.mcpServers) ?? {});
+      remainingHost ||= servers.mason !== void 0;
+    });
+    await attempt(configPath(host), async () => {
+      const config = automationConfigSchema.parse(JSON.parse(await read(configPath(host)) ?? "{}"));
+      remainingHost ||= Object.values(config.hooks ?? {}).some((groups) => groups.some((group) => group.hooks.some((handler) => handler.command && possibleHook(handler.command, host))));
+    });
+  }
+  for (const host of selected) {
+    const mcpFile = mcpPath(host);
+    await attempt(mcpFile, async () => {
+      const before = await read(mcpFile);
+      if (before === null) return;
+      const config = host === "codex" ? parse3(before) : object2.parse(JSON.parse(before));
+      const key = host === "codex" ? "mcp_servers" : "mcpServers";
+      const servers = object2.parse(config[key] ?? {});
+      if (servers.mason === void 0) {
+        if (host === "codex" && BLOCKS[2].some((marker) => before.includes(marker))) throw new Error("The marked Mason MCP entry was removed or renamed; inspect the retained block manually.");
+        return;
+      }
+      const expected = ownership.files[mcpFile]?.mcpHash ?? hash(mcpCommand(host));
+      if (hash(servers.mason) !== expected) throw new Error("The Mason MCP entry was edited or its ownership is uncertain; retained for manual cleanup.");
+      delete servers.mason;
+      const desired = { ...config, [key]: servers };
+      if (!Object.keys(servers).length) delete desired[key];
+      if (host === "claude") {
+        add(mcpFile, before, json(desired), !Object.keys(desired).length);
+        return;
+      }
+      const [start, end] = BLOCKS[2], block = blockSpan(before, start, end);
+      if (!block) throw new Error("Mason MCP markers are missing; retained for manual cleanup.");
+      const expectedBlock = ownership.files[mcpFile]?.blocks[start];
+      const canonicalBlock = managedBlock("", start, end, stringify2({ mcp_servers: { mason: mcpCommand(host) } }).trimEnd()).trimEnd();
+      if (expectedBlock ? hash(block.text) !== expectedBlock : block.text.replace(/\r\n/g, "\n") !== canonicalBlock) {
+        throw new Error("The Mason MCP block was edited; retained for manual cleanup.");
+      }
+      const after = before.slice(0, block.from) + before.slice(block.to).replace(/^\r?\n/, "");
+      const parsed = parse3(after);
+      if (!Object.keys(servers).length && parsed[key] !== void 0) desired[key] = {};
+      if (!isDeepStrictEqual2(parsed, desired)) throw new Error("Removing the marked block would change other TOML settings; retained for manual cleanup.");
+      add(mcpFile, before, after, !after.trim());
+    });
+    const hookFile = configPath(host);
+    await attempt(hookFile, async () => {
+      const before = await read(hookFile);
+      if (before === null) return;
+      const config = automationConfigSchema.parse(JSON.parse(before));
+      let changed = false;
+      for (const [event, groups] of Object.entries(config.hooks ?? {})) {
+        const known = ownership.files[hookFile]?.hooks?.[event];
+        const handlers = groups.flatMap((group) => group.hooks);
+        if (known && !handlers.some((handler) => handler.type === "command" && handler.command && commands(host).has(handler.command)) && handlers.some((handler) => !known.includes(hash(handler)))) {
+          diagnostics.push({ path: hookFile, message: "A recorded Mason hook is missing beside a new or edited handler (" + event + "); inspect ownership manually." });
+        }
+        const kept = groups.flatMap((group) => {
+          const handlers2 = group.hooks.filter((handler) => {
+            if (handler.type === "command" && handler.command && commands(host).has(handler.command)) {
+              changed = true;
+              return false;
+            }
+            if (handler.command && possibleHook(handler.command, host)) diagnostics.push({
+              path: hookFile,
+              message: "An unrecognized Mason hook was retained for manual cleanup (" + event + ")."
+            });
+            return true;
+          });
+          return handlers2.length === group.hooks.length ? [group] : handlers2.length ? [{ ...group, hooks: handlers2 }] : [];
+        });
+        if (kept.length || !groups.length) config.hooks[event] = kept;
+        else delete config.hooks[event];
+      }
+      if (!changed) return;
+      if (!Object.keys(config.hooks ?? {}).length) delete config.hooks;
+      add(hookFile, before, json(config), !Object.keys(config).length);
+    });
+  }
+  const instructionEditStart = edits.length;
+  if (!remainingHost && !diagnostics.length) for (const file of DOC_CANDIDATES) await attempt(file, async () => {
+    const before = await read(file);
+    if (before === null) return;
+    let after = before;
+    for (const [start, end] of BLOCKS.slice(0, 2)) {
+      const block = blockSpan(after, start, end);
+      if (!block) continue;
+      const pointer = "Mason project knowledge and shared project instructions:\n@" + (file.startsWith(".claude/") ? "../AGENTS.md" : "AGENTS.md");
+      const canonical = [CLAUDE_MD_SECTION, managedBlock("", start, end, pointer).trimEnd()];
+      const expected = ownership.files[file]?.blocks[start];
+      if (expected ? hash(block.text) !== expected : !canonical.includes(block.text.replace(/\r\n/g, "\n"))) {
+        throw new Error("The Mason instruction block was edited or is unrecognized; retained for manual cleanup.");
+      }
+      after = after.slice(0, block.from) + after.slice(block.to).replace(/^\r?\n/, "");
+    }
+    if (after !== before) add(file, before, after, !after.trim());
+  });
+  if (diagnostics.length) edits.splice(instructionEditStart);
+  if (!diagnostics.length) {
+    const cleanup = [];
+    const receiptFiles = await fg5(
+      selected.map((host) => ".mason/reports/automation/*/setup-" + host + ".json"),
+      { cwd: root, dot: true, onlyFiles: false, followSymbolicLinks: false }
+    );
+    if (receiptFiles.length > 1e3) throw new Error("Too many setup receipts; inspect local setup history before teardown.");
+    for (const file of receiptFiles.sort()) await attempt(file, async () => {
+      const host = file.endsWith("setup-codex.json") ? "codex" : "claude";
+      await loadSetupReceipt(root, file.slice(0, file.lastIndexOf("/")), host);
+      cleanup.push({ path: file, before: await read(file), after: null });
+    });
+    if (!remainingHost) await attempt(".mason/local/project.json", async () => {
+      const before = await read(".mason/local/project.json");
+      if (before === null) return;
+      z14.object({ version: z14.literal(1), initializedAt: z14.string() }).strict().parse(JSON.parse(before));
+      cleanup.push({ path: ".mason/local/project.json", before, after: null });
+    });
+    if (!diagnostics.length) {
+      for (const host of selected) {
+        if (setup) delete setup.hosts[host];
+        if (automation) delete automation.hosts[host];
+        delete ownership.files[mcpPath(host)];
+        delete ownership.files[configPath(host)];
+      }
+      if (!remainingHost) for (const file of DOC_CANDIDATES) delete ownership.files[file];
+      if (setupBefore !== null) cleanup.push({ path: SETUP_PATH, before: setupBefore, after: Object.keys(setup.hosts).length ? json(setup) : null });
+      if (automationBefore !== null) cleanup.push({ path: AUTOMATION_PATH, before: automationBefore, after: Object.keys(automation.hosts).length ? json(automation) : null });
+      if (ownershipBefore !== null) cleanup.push({ path: OWNERSHIP_PATH, before: ownershipBefore, after: Object.keys(ownership.files).length ? json(ownership) : null });
+      edits.push(...cleanup);
+    }
+  }
+  return { edits: edits.filter((edit) => edit.before !== edit.after), diagnostics, remainingHost, inputs };
+}
+async function teardownProject(dir, options = {}) {
+  const { root } = await workspace(dir);
+  const selected = options.host ? [options.host] : [...hosts];
+  const run = async (apply) => {
+    const plan = await planTeardown(root, selected);
+    if (apply) {
+      for (const [file, before] of plan.inputs) if (await readText(root, file) !== before) throw new Error("Input changed during teardown: " + file + ". Rerun teardown.");
+      for (const edit of plan.edits) await applyEdit(root, edit);
+    }
+    return {
+      version: 1,
+      action: "teardown",
+      status: plan.diagnostics.length ? "incomplete" : "complete",
+      root,
+      hosts: selected,
+      dryRun: !!options.dryRun,
+      changes: plan.edits.map((edit) => ({ path: edit.path, action: edit.after === null ? "delete" : "update" })),
+      diagnostics: plan.diagnostics,
+      sharedInstructionsRetained: plan.remainingHost || !!plan.diagnostics.length,
+      next: plan.diagnostics.length ? "Inspect the retained entries, remove or correct them, then rerun teardown." : "Restart running assistants to unload the project integration. Run mason setup --host codex or --host claude to reconnect."
+    };
+  };
+  const preview = await run(false);
+  if (options.dryRun || !preview.changes.length) return preview;
+  return withLock(root, ".mason/reports/setup-lock", () => run(true));
+}
+function summarizeTeardown(result) {
+  return [
+    `Mason teardown${result.dryRun ? " preview" : ""}: ${result.status}.`,
+    ...result.changes.map((change) => `  ${result.dryRun ? "Would " : ""}${change.action}: ${change.path}`),
+    ...result.diagnostics.map((item) => `  Retained ${item.path}: ${item.message}`),
+    ...!result.changes.length ? ["No changes."] : [],
+    "Shared knowledge, repair evidence, ignore rules and the installed Mason command are retained.",
+    ...result.sharedInstructionsRetained ? ["Shared instruction cleanup is deferred while another host or incomplete removal needs inspection."] : [],
+    ...result.dryRun ? ["Preview only; no files were changed."] : [result.next]
+  ].join("\n");
+}
+var hosts, object2, json;
+var init_teardown = __esm({
+  "src/setup/teardown.ts"() {
+    "use strict";
+    init_evidence();
+    init_store();
+    init_install();
+    init_adapters();
+    init_docs();
+    init_init();
+    init_files2();
+    init_config();
+    init_launcher();
+    init_model();
+    init_ownership();
+    hosts = ["codex", "claude"];
+    object2 = z14.record(z14.unknown());
+    json = (value) => JSON.stringify(value, null, 2) + "\n";
+  }
+});
+
 // src/review/cochange.ts
 import { execFile as execFile11 } from "child_process";
 import { promisify as promisify11 } from "util";
@@ -3605,7 +3927,7 @@ var init_types2 = __esm({
 });
 
 // src/review/evidence/vitest.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function parseVitest(raw, sourceRoot) {
   const report = schema.parse(raw);
   const findings = [], diagnostics = [];
@@ -3654,24 +3976,24 @@ var init_vitest = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    count2 = z13.number().int().nonnegative();
-    schema = z13.object({
-      success: z13.boolean(),
+    count2 = z15.number().int().nonnegative();
+    schema = z15.object({
+      success: z15.boolean(),
       numTotalTests: count2,
       numPassedTests: count2,
       numFailedTests: count2,
       numPendingTests: count2,
       numTodoTests: count2,
       numFailedTestSuites: count2,
-      testResults: z13.array(z13.object({
-        name: z13.string().min(1),
-        status: z13.enum(["passed", "failed"]),
-        message: z13.string().optional(),
-        assertionResults: z13.array(z13.object({
-          fullName: z13.string(),
-          status: z13.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
-          failureMessages: z13.array(z13.string()).nullable().optional(),
-          location: z13.object({ line: count2, column: count2 }).nullable().optional()
+      testResults: z15.array(z15.object({
+        name: z15.string().min(1),
+        status: z15.enum(["passed", "failed"]),
+        message: z15.string().optional(),
+        assertionResults: z15.array(z15.object({
+          fullName: z15.string(),
+          status: z15.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
+          failureMessages: z15.array(z15.string()).nullable().optional(),
+          location: z15.object({ line: count2, column: count2 }).nullable().optional()
         }))
       }))
     });
@@ -3679,7 +4001,7 @@ var init_vitest = __esm({
 });
 
 // src/review/evidence/sarif.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 function parseSarif(raw, sourceRoot) {
   const report = schema2.parse(raw), findings = [], diagnostics = [];
   let active = 0, suppressed = 0, absent = 0, unresolved = 0;
@@ -3770,29 +4092,29 @@ var init_sarif = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    index = z14.number().int().nonnegative();
-    artifact = z14.object({ uri: z14.string().optional(), uriBaseId: z14.string().optional(), index: index.optional() });
-    message = z14.object({ text: z14.string().optional(), markdown: z14.string().optional(), id: z14.string().optional(), arguments: z14.array(z14.string()).optional() });
-    level = z14.enum(["error", "warning", "note", "none"]);
-    location = z14.object({ physicalLocation: z14.object({ artifactLocation: artifact.optional(), region: z14.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
-    schema2 = z14.object({
-      version: z14.literal("2.1.0"),
-      runs: z14.array(z14.object({
-        tool: z14.object({ driver: z14.object({ name: z14.string().min(1), rules: z14.array(z14.object({ id: z14.string(), defaultConfiguration: z14.object({ level: level.optional() }).optional(), messageStrings: z14.record(message).optional() })).optional(), globalMessageStrings: z14.record(message).optional() }) }),
-        invocations: z14.array(z14.object({ executionSuccessful: z14.boolean(), commandLine: z14.string().optional(), toolExecutionNotifications: z14.array(z14.object({ level: level.optional(), message })).optional() })).optional(),
-        versionControlProvenance: z14.array(z14.object({ revisionId: z14.string().optional() })).optional(),
-        originalUriBaseIds: z14.record(artifact).optional(),
-        artifacts: z14.array(z14.object({ location: artifact.optional() })).optional(),
-        results: z14.array(z14.object({
-          ruleId: z14.string().optional(),
+    index = z16.number().int().nonnegative();
+    artifact = z16.object({ uri: z16.string().optional(), uriBaseId: z16.string().optional(), index: index.optional() });
+    message = z16.object({ text: z16.string().optional(), markdown: z16.string().optional(), id: z16.string().optional(), arguments: z16.array(z16.string()).optional() });
+    level = z16.enum(["error", "warning", "note", "none"]);
+    location = z16.object({ physicalLocation: z16.object({ artifactLocation: artifact.optional(), region: z16.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
+    schema2 = z16.object({
+      version: z16.literal("2.1.0"),
+      runs: z16.array(z16.object({
+        tool: z16.object({ driver: z16.object({ name: z16.string().min(1), rules: z16.array(z16.object({ id: z16.string(), defaultConfiguration: z16.object({ level: level.optional() }).optional(), messageStrings: z16.record(message).optional() })).optional(), globalMessageStrings: z16.record(message).optional() }) }),
+        invocations: z16.array(z16.object({ executionSuccessful: z16.boolean(), commandLine: z16.string().optional(), toolExecutionNotifications: z16.array(z16.object({ level: level.optional(), message })).optional() })).optional(),
+        versionControlProvenance: z16.array(z16.object({ revisionId: z16.string().optional() })).optional(),
+        originalUriBaseIds: z16.record(artifact).optional(),
+        artifacts: z16.array(z16.object({ location: artifact.optional() })).optional(),
+        results: z16.array(z16.object({
+          ruleId: z16.string().optional(),
           ruleIndex: index.optional(),
           message,
           level: level.optional(),
-          kind: z14.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
-          baselineState: z14.enum(["new", "unchanged", "updated", "absent"]).optional(),
-          suppressions: z14.array(z14.object({ kind: z14.enum(["inSource", "external"]), status: z14.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
-          locations: z14.array(location).optional(),
-          relatedLocations: z14.array(location).optional()
+          kind: z16.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
+          baselineState: z16.enum(["new", "unchanged", "updated", "absent"]).optional(),
+          suppressions: z16.array(z16.object({ kind: z16.enum(["inSource", "external"]), status: z16.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
+          locations: z16.array(location).optional(),
+          relatedLocations: z16.array(location).optional()
         })).optional()
       }))
     });
@@ -3801,7 +4123,7 @@ var init_sarif = __esm({
 
 // src/review/evidence.ts
 import path19 from "path";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 function relativeArtifact(root, file) {
   const relative = path19.isAbsolute(file) ? path19.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
@@ -3842,7 +4164,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
     let manifest, raw;
     try {
       manifest = relativeArtifact(root, supplied);
-      raw = z15.object({ version: z15.literal(1), checks: z15.array(z15.unknown()) }).parse(await readStoreJson(root, manifest));
+      raw = z17.object({ version: z17.literal(1), checks: z17.array(z17.unknown()) }).parse(await readStoreJson(root, manifest));
     } catch (error) {
       output.diagnostics.push(`${supplied}: ${String(error)}`);
       continue;
@@ -3995,19 +4317,19 @@ var init_evidence2 = __esm({
     init_vitest();
     init_sarif();
     init_types2();
-    checkSchema2 = z15.object({
-      id: z15.string().min(1).max(100),
-      kind: z15.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
-      tool: z15.string().min(1).max(200),
-      command: z15.string().min(1).max(2e3),
-      commit: z15.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
-      workingTreeClean: z15.boolean().optional(),
-      source: z15.string().max(2e3).optional(),
-      sourceRoot: z15.string().min(1).max(4e3).optional(),
-      status: z15.enum(["completed", "skipped", "unavailable"]).default("completed"),
-      reason: z15.string().min(1).max(2e3).optional(),
-      exitCode: z15.number().int().nullable().optional(),
-      report: z15.object({ format: z15.enum(["vitest-json", "sarif"]), path: z15.string().min(1).max(4e3) }).optional()
+    checkSchema2 = z17.object({
+      id: z17.string().min(1).max(100),
+      kind: z17.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
+      tool: z17.string().min(1).max(200),
+      command: z17.string().min(1).max(2e3),
+      commit: z17.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
+      workingTreeClean: z17.boolean().optional(),
+      source: z17.string().max(2e3).optional(),
+      sourceRoot: z17.string().min(1).max(4e3).optional(),
+      status: z17.enum(["completed", "skipped", "unavailable"]).default("completed"),
+      reason: z17.string().min(1).max(2e3).optional(),
+      exitCode: z17.number().int().nullable().optional(),
+      report: z17.object({ format: z17.enum(["vitest-json", "sarif"]), path: z17.string().min(1).max(4e3) }).optional()
     });
   }
 });
@@ -4233,7 +4555,7 @@ __export(status_exports, {
   setupStatus: () => setupStatus,
   summarizeActivation: () => summarizeActivation
 });
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 async function setupStatus(dir) {
   const ws = await workspace(dir);
   const setup = await loadSetup(ws.root);
@@ -4250,7 +4572,7 @@ async function setupStatus(dir) {
       next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Run mason-auto setup --host codex or --host claude."
     };
   }
-  const hosts = {};
+  const hosts2 = {};
   const installed = await installedCommand();
   const automation = await automationStatus(ws.root);
   for (const host of ["codex", "claude"]) {
@@ -4259,8 +4581,8 @@ async function setupStatus(dir) {
     const instructions = await instructionEdits(ws.root, host);
     const instructionsCurrent = instructions.every((edit) => edit.before === edit.after);
     const config = await inspectHostConfig(ws.root, host, void 0);
-    const mcp = !config.mcpDisabled && hash(config.mcp) === entry.mcpFingerprint && isDeepStrictEqual2({ command: config.mcp?.command, args: config.mcp?.args }, mcpCommand(host));
-    const hooks = isDeepStrictEqual2(config.hooks, hookConfig(host, hookCommand(host)).hooks) && !config.disabled;
+    const mcp = !config.mcpDisabled && hash(config.mcp) === entry.mcpFingerprint && isDeepStrictEqual3({ command: config.mcp?.command, args: config.mcp?.args }, mcpCommand(host));
+    const hooks = isDeepStrictEqual3(config.hooks, hookConfig(host, hookCommand(host)).hooks) && !config.disabled;
     const local = await loadSetupReceipt(ws.root, ws.directory, host);
     const configured = local?.status === "configured" && local.root === ws.root && local.revision === entry.revision;
     const observation = await readObservation(ws.root, ws.directory, host, entry.revision, installed.version ?? "unavailable");
@@ -4274,7 +4596,7 @@ async function setupStatus(dir) {
     if (!complete) pending.push("Review/trust the host configuration, then complete a normal task to observe the full hook lifecycle.");
     if (automation.status === "unavailable") pending.push("The latest automation attempt did not establish verification. Run mason-auto check and inspect its diagnostics.");
     const healthy = installed.available && mcp && hooks && instructionsCurrent && configured && automation.status !== "unavailable";
-    hosts[host] = {
+    hosts2[host] = {
       status: healthy ? complete && observation?.contextCalls ? "active" : "pending" : "attention",
       runtime: installed.available ? "global (" + installed.version + ")" : "unavailable-on-path",
       mcp: mcp ? "configured" : "changed",
@@ -4286,13 +4608,13 @@ async function setupStatus(dir) {
       pending
     };
   }
-  const statuses = Object.values(hosts).map((host) => host.status);
+  const statuses = Object.values(hosts2).map((host) => host.status);
   const decisions = await loadDecisionStore(ws.root);
   return {
     version: 1,
     status: statuses.length && statuses.every((status) => status === "active") ? "active" : statuses.includes("attention") ? "attention" : "pending",
     root: ws.root,
-    hosts,
+    hosts: hosts2,
     decisionRecords: decisions.records.length,
     diagnostics: decisions.diagnostics,
     scope: "Activation receipts record observed use after setup, not complete interception, correct repairs, or measured usefulness. Host trust and higher-priority settings may prevent execution. Receipts are local to this worktree and branch."
@@ -4361,6 +4683,8 @@ async function setupProject(dir, options = {}) {
     const setupBefore = await readText(ws.root, SETUP_PATH);
     const mcpFingerprint = hash((await inspectHostConfig(ws.root, host, mcp.after)).mcp);
     const desiredHooks = hookConfig(host, hookCommand(host)).hooks;
+    const configuredHook = desiredHooks.SessionStart[0].hooks[0].command;
+    const ownership = await ownershipEdit(ws.root, [...instructions, mcp, hooks[0]], { [hooks[0].path]: configuredHook });
     const fingerprint = hash({
       command: "mason",
       mcp: mcpFingerprint,
@@ -4387,8 +4711,10 @@ async function setupProject(dir, options = {}) {
       revision
     });
     const changedFiles = [];
+    if (await applyEdit(ws.root, ownership)) changedFiles.push(ownership.path);
     for (const edit of edits) if (await applyEdit(ws.root, edit)) changedFiles.push(edit.path);
     if (await applyEdit(ws.root, { path: SETUP_PATH, before: setupBefore, after: JSON.stringify(setup, null, 2) + "\n" })) changedFiles.push(SETUP_PATH);
+    if (await applyEdit(ws.root, await completedHookOwnership(ws.root, hooks[0].path, configuredHook)) && !changedFiles.includes(ownership.path)) changedFiles.push(ownership.path);
     const checked = await automate(ws.root, { event: "turn_start" });
     const configured = await inspectHostConfig(ws.root, host, void 0);
     await writeStoreJson(ws.root, receiptPath, {
@@ -4447,6 +4773,7 @@ var init_setup = __esm({
     init_adapters();
     init_model();
     init_status();
+    init_ownership();
   }
 });
 
@@ -4457,9 +4784,23 @@ init_adapters();
 init_install();
 init_store();
 import { parseArgs } from "util";
-var USAGE = `Usage: mason-auto <setup|install|config|status|check|hook> [options]
+var TEARDOWN_USAGE = `Usage: mason teardown [options]
+
+Disconnect Mason from this Git project. Defaults to all project hosts.
+
+  --host codex|claude         Disconnect only this host
+  --dir <path>               Project directory (defaults to cwd; subdirectories work)
+  --dry-run                  Preview changes without writing
+  --json                     Machine-readable changes and diagnostics
+
+Keeps shared knowledge, repair evidence, ignore rules and the Mason installation.
+Edited or ambiguous entries are retained for manual cleanup. Restart assistants
+after teardown. Run mason setup --host codex or --host claude to reconnect.
+Exit 0: complete/no-op. Exit 2: cleanup needs attention (also in dry runs).`;
+var USAGE = `Usage: mason-auto <setup|teardown|install|config|status|check|hook> [options]
 
   setup [--host claude|codex]  Connect MCP, instructions and hooks to mason on PATH; retain the initial audit
+  teardown [--host claude|codex] Disconnect one host or all project hosts; retain knowledge and evidence
   install --host claude|codex  Merge lifecycle hooks into this project's host config
   config --host claude|codex   Print the host config without writing
   status                      Read configured hooks and observed runtime events
@@ -4468,9 +4809,11 @@ var USAGE = `Usage: mason-auto <setup|install|config|status|check|hook> [options
 
   --dir <path>                Project directory (defaults to cwd)
   --command <prefix>          Installed executable prefix for install/config
+  --dry-run                   Preview teardown without writing
   --json                      Machine-readable output (status also uses JSON when piped)
 
 check exits 0 for verified checks, 1 for issues, 2 for incomplete/unavailable.
+teardown exits 0 for complete/no-op, 2 when cleanup needs attention (also in dry runs).
 Hooks are advisory and exit 0; a failed capture is reported explicitly.
 Local evidence is written under .mason/reports/. No LLM calls or source edits.`;
 var parseCli = (argv2) => parseArgs({ args: argv2, allowPositionals: true, options: {
@@ -4478,7 +4821,8 @@ var parseCli = (argv2) => parseArgs({ args: argv2, allowPositionals: true, optio
   host: { type: "string" },
   command: { type: "string" },
   json: { type: "boolean" },
-  help: { type: "boolean", short: "h" }
+  help: { type: "boolean", short: "h" },
+  "dry-run": { type: "boolean" }
 } });
 function isHookCommand(argv2) {
   try {
@@ -4496,12 +4840,20 @@ async function runAutomationCli(argv2, stdin = "", io = {
   try {
     const { values, positionals } = parseCli(argv2);
     if (values.help || !positionals.length) {
-      io.out(USAGE);
+      io.out(positionals[0] === "teardown" ? TEARDOWN_USAGE : USAGE);
       return 0;
     }
     if (positionals.length !== 1) throw new Error("Expected one command.");
     [action] = positionals;
     const dir = values.dir ?? process.cwd();
+    if (values["dry-run"] !== void 0 && action !== "teardown") throw new Error("--dry-run applies only to teardown.");
+    if (action === "teardown") {
+      if (values.command !== void 0) throw new Error("--command applies only to install/config.");
+      const { teardownProject: teardownProject2, summarizeTeardown: summarizeTeardown2 } = await Promise.resolve().then(() => (init_teardown(), teardown_exports));
+      const result = await teardownProject2(dir, { host: values.host === void 0 ? void 0 : hostSchema.parse(values.host), dryRun: values["dry-run"] });
+      io.out(values.json ? JSON.stringify(result, null, 2) : summarizeTeardown2(result));
+      return result.status === "complete" ? 0 : 2;
+    }
     if (action === "hook") {
       const output = await runAutomationHook(hostSchema.parse(values.host), stdin);
       if (output) io.out(JSON.stringify(output));
@@ -4532,12 +4884,12 @@ async function runAutomationCli(argv2, stdin = "", io = {
     io.out(values.json ? JSON.stringify(report, null, 2) : summarize(report));
     return report.status === "verified" ? 0 : report.status === "issues-remain" ? 1 : 2;
   } catch (error) {
-    const message2 = action === "setup" ? "Mason setup incomplete: " + automationFailure(error).message + ". Rerun the same setup command to resume; retained audit evidence is preserved." : failureMessage(error);
+    const message2 = action === "setup" ? "Mason setup incomplete: " + automationFailure(error).message + ". Rerun the same setup command to resume; retained audit evidence is preserved." : action === "teardown" ? "Mason teardown incomplete: " + automationFailure(error).message + ". Inspect the reported input, then rerun teardown; knowledge and repair evidence are retained." : failureMessage(error);
     if (action === "hook" || isHookCommand(argv2)) {
       io.out(JSON.stringify({ systemMessage: message2 }));
       return 0;
     }
-    if (argv2.includes("--json")) io.out(JSON.stringify({ version: 1, ...action === "setup" ? { action, status: "incomplete", next: "Rerun the same setup command to resume." } : { status: "unavailable" }, failure: automationFailure(error) }));
+    if (argv2.includes("--json")) io.out(JSON.stringify({ version: 1, ...["setup", "teardown"].includes(action) ? { action, status: "incomplete", next: "Inspect the reported input, then rerun the same command to resume." } : { status: "unavailable" }, failure: automationFailure(error) }));
     else io.err(message2);
     return 2;
   }