safeword 0.74.3 → 0.74.4

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "safeword",
-  "version": "0.74.3",
+  "version": "0.74.4",
   "description": "Safe Word workflow guidance and gates for Codex.",
   "author": {
     "name": "Arcade AI"

package/codex-plugin/hooks.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bunx --bun safeword@0.74.3 hook codex session-start --plugin-hook",
+            "command": "bunx --bun safeword@0.74.4 hook codex session-start --plugin-hook",
             "timeout": 120,
             "statusMessage": "Loading Safe Word standing instructions"
           }
@@ -19,7 +19,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bunx --bun safeword@0.74.3 hook codex pre-tool-use --plugin-hook",
+            "command": "bunx --bun safeword@0.74.4 hook codex pre-tool-use --plugin-hook",
             "timeout": 30,
             "statusMessage": "Checking Safe Word edit gates"
           }
@@ -32,7 +32,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bunx --bun safeword@0.74.3 hook codex post-tool-use --plugin-hook",
+            "command": "bunx --bun safeword@0.74.4 hook codex post-tool-use --plugin-hook",
             "timeout": 30,
             "statusMessage": "Surfacing Safe Word post-tool context"
           }
@@ -45,7 +45,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bunx --bun safeword@0.74.3 hook codex user-prompt-submit --plugin-hook",
+            "command": "bunx --bun safeword@0.74.4 hook codex user-prompt-submit --plugin-hook",
             "timeout": 30,
             "statusMessage": "Checking queued Safe Word prompt context"
           }
@@ -58,7 +58,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bunx --bun safeword@0.74.3 hook codex stop --plugin-hook",
+            "command": "bunx --bun safeword@0.74.4 hook codex stop --plugin-hook",
             "timeout": 600,
             "statusMessage": "Checking Safe Word stop continuation"
           }

package/dist/{architecture-ZM6AM3AZ.js → architecture-I5I63ODT.js}

@@ -25,7 +25,7 @@ import {
   readJson,
   writeJson
 } from "./chunk-7G6OSNIV.js";
-import "./chunk-KUBO23BM.js";
+import "./chunk-LDPULEYD.js";
 
 // src/commands/architecture.ts
 import { execFileSync } from "child_process";
@@ -650,4 +650,4 @@ export {
   architectureStage,
   architectureStaged
 };
-//# sourceMappingURL=architecture-ZM6AM3AZ.js.map
+//# sourceMappingURL=architecture-I5I63ODT.js.map

package/dist/{architecture-document-Q3LWXN3U.js → architecture-document-HD3YGB6N.js}

@@ -11,7 +11,7 @@ import {
 import "./chunk-YP2V3YUV.js";
 import "./chunk-2MI7M2CO.js";
 import "./chunk-7G6OSNIV.js";
-import "./chunk-KUBO23BM.js";
+import "./chunk-LDPULEYD.js";
 export {
   isSafewordOwned,
   isWouldChangeAction,
@@ -22,4 +22,4 @@ export {
   selfHealProject,
   selfHealProjectPreservingProse
 };
-//# sourceMappingURL=architecture-document-Q3LWXN3U.js.map
+//# sourceMappingURL=architecture-document-HD3YGB6N.js.map

package/dist/{architecture-monorepo-U4G4Y4RC.js → architecture-monorepo-YLM3QZRC.js}

@@ -5,11 +5,11 @@ import {
   monorepoFingerprintOf
 } from "./chunk-YP2V3YUV.js";
 import "./chunk-7G6OSNIV.js";
-import "./chunk-KUBO23BM.js";
+import "./chunk-LDPULEYD.js";
 export {
   discoverUnreadableWorkspaces,
   discoverWorkspaces,
   extractMonorepoArchitectureSnapshot,
   monorepoFingerprintOf
 };
-//# sourceMappingURL=architecture-monorepo-U4G4Y4RC.js.map
+//# sourceMappingURL=architecture-monorepo-YLM3QZRC.js.map

package/dist/{boundary-TPREVQVV.js → boundary-YHU7JNQP.js}

@@ -5,15 +5,15 @@ import {
   parseImplPlan,
   scalar
 } from "./chunk-SPK32BMX.js";
+import {
+  createPhaseAnchorScope
+} from "./chunk-K64BTVJ7.js";
 import {
   classifyAnnotation,
   isValidSha,
   isValidSkipReason,
   parseCheckboxAnnotation
 } from "./chunk-Z4ESH6KU.js";
-import {
-  createPhaseAnchorScope
-} from "./chunk-K64BTVJ7.js";
 import "./chunk-URVJZ4NL.js";
 import {
   warn
@@ -25,7 +25,7 @@ import {
 import {
   readFileSafe
 } from "./chunk-7G6OSNIV.js";
-import "./chunk-KUBO23BM.js";
+import "./chunk-LDPULEYD.js";
 
 // src/commands/boundary.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -628,4 +628,4 @@ function boundary(options) {
 export {
   boundary
 };
-//# sourceMappingURL=boundary-TPREVQVV.js.map
+//# sourceMappingURL=boundary-YHU7JNQP.js.map

package/dist/{chunk-RHIDFAQA.js → chunk-2PS33UXO.js}

@@ -1,7 +1,7 @@
 import {
   durableRename,
   writeDurableFile
-} from "./chunk-UTO5XZ4S.js";
+} from "./chunk-QOLHGAD5.js";
 import {
   CODEX_MIGRATION_SCHEMA
 } from "./chunk-XHNWNZRM.js";
@@ -479,4 +479,4 @@ export {
   observeCodexRecoveryPlan,
   applyCodexFinalization
 };
-//# sourceMappingURL=chunk-RHIDFAQA.js.map
+//# sourceMappingURL=chunk-2PS33UXO.js.map

package/dist/chunk-4HQHVNDP.js

@@ -0,0 +1,445 @@
+import {
+  canonicalClaudeProjectRoot
+} from "./chunk-JVZIT7JQ.js";
+import {
+  advisoryStateDigest,
+  claudeWatchedSettingsDigest,
+  createClaudePluginMode,
+  writeClaudeMigrationAttention,
+  writeClaudePluginMode
+} from "./chunk-OCXDMJQA.js";
+import {
+  assertSafeClaudeCleanupTarget,
+  containedClaudeCleanupPath,
+  observeClaudeLegacy
+} from "./chunk-BTY7MFRX.js";
+import {
+  CLAUDE_MIGRATION_SCHEMA
+} from "./chunk-6ORAURPL.js";
+import {
+  writeDurableFile,
+  writeDurableFileExclusive
+} from "./chunk-QOLHGAD5.js";
+import {
+  createResult
+} from "./chunk-6Z2GFE27.js";
+
+// src/claude-plugin/cleanup.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmdirSync,
+  rmSync
+} from "fs";
+import nodePath from "path";
+import { applyEdits, modify, parse, visit } from "jsonc-parser";
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function containsJsonComments(content) {
+  let found = false;
+  visit(content, { onComment: () => found = true });
+  return found;
+}
+function settingsMutation(cwd, legacy) {
+  const relative = ".claude/settings.json";
+  const path = nodePath.join(cwd, relative);
+  if (!existsSync(path) || legacy.recognizedHooks.length === 0) return void 0;
+  const original = readFileSync(path, "utf8");
+  const parsed = parse(original);
+  const hooks = parsed.hooks ?? {};
+  const allHookValuesAreArrays = Object.values(hooks).every((entries) => Array.isArray(entries));
+  const hookCount = Object.values(hooks).reduce(
+    (count, entries) => count + (Array.isArray(entries) ? entries.length : 0),
+    0
+  );
+  const generatedHookOnlyFile = Object.keys(parsed).length === 1 && allHookValuesAreArrays && hookCount === legacy.recognizedHooks.length && !containsJsonComments(original);
+  if (generatedHookOnlyFile) return { path: relative, content: null };
+  let content = original;
+  const references = legacy.recognizedHooks.toSorted((left, right) => {
+    const eventOrder = right.event.localeCompare(left.event);
+    return eventOrder === 0 ? right.index - left.index : eventOrder;
+  });
+  for (const reference of references) {
+    content = applyEdits(
+      content,
+      modify(content, ["hooks", reference.event, reference.index], void 0, {
+        formattingOptions: { insertSpaces: true, tabSize: 2 }
+      })
+    );
+  }
+  return {
+    path: relative,
+    content
+  };
+}
+function claudeLegacyMutations(cwd) {
+  const legacy = observeClaudeLegacy(cwd);
+  const files = legacy.recognizedFiles.map((path) => ({
+    path,
+    content: null
+  }));
+  const settings = settingsMutation(cwd, legacy);
+  if (settings !== void 0) files.push(settings);
+  return files;
+}
+function claudeCleanupPreconditionDigest(cwd, mutations) {
+  return sha256(
+    JSON.stringify(
+      mutations.map((mutation) => {
+        const target = assertSafeClaudeCleanupTarget(cwd, mutation.path);
+        return [mutation.path, sha256(readFileSync(target)), mutation.content];
+      })
+    )
+  );
+}
+function transactionPath(cwd) {
+  return containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.transaction);
+}
+function writeTransaction(cwd, transaction) {
+  const path = transactionPath(cwd);
+  mkdirSync(nodePath.dirname(path), { recursive: true, mode: 448 });
+  writeDurableFileExclusive(path, `${JSON.stringify(transaction, void 0, 2)}
+`, {
+    mode: 384
+  });
+}
+function entryFor(cwd, mutation) {
+  const path = assertSafeClaudeCleanupTarget(cwd, mutation.path);
+  const before = readFileSync(path);
+  const after = mutation.content === null ? null : Buffer.from(mutation.content);
+  return {
+    path: mutation.path,
+    before_sha256: sha256(before),
+    before_base64: before.toString("base64"),
+    before_mode: lstatSync(path).mode & 511,
+    after_sha256: after === null ? null : sha256(after),
+    after_base64: after === null ? null : after.toString("base64"),
+    after_mode: after === null ? null : lstatSync(path).mode & 511
+  };
+}
+function observedSha(path) {
+  return existsSync(path) ? sha256(readFileSync(path)) : null;
+}
+function pruneEmptyAncestors(root, path) {
+  const canonicalRoot = nodePath.resolve(root);
+  let directory = nodePath.dirname(nodePath.resolve(path));
+  while (directory.startsWith(`${canonicalRoot}${nodePath.sep}`)) {
+    try {
+      if (readdirSync(directory).length > 0) return;
+      rmdirSync(directory);
+    } catch {
+      return;
+    }
+    directory = nodePath.dirname(directory);
+  }
+}
+function writeImage(root, path, content, mode) {
+  if (content === null) {
+    rmSync(path, { force: true });
+    pruneEmptyAncestors(root, path);
+    return;
+  }
+  mkdirSync(nodePath.dirname(path), { recursive: true });
+  writeDurableFile(path, Buffer.from(content, "base64"), { mode: mode ?? 420 });
+  chmodSync(path, mode ?? 420);
+}
+function applyEntries(cwd, entries, shouldDefer = () => false) {
+  for (const entry of entries) {
+    if (shouldDefer()) return false;
+    const path = assertSafeClaudeCleanupTarget(cwd, entry.path);
+    if (observedSha(path) !== entry.before_sha256) {
+      throw new Error(`Claude cleanup target changed after planning: ${entry.path}`);
+    }
+    writeImage(cwd, path, entry.after_base64, entry.after_mode);
+  }
+  return true;
+}
+function writePluginModeMarker(cwd, transactionId) {
+  const marker = containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.pluginMarker);
+  mkdirSync(nodePath.dirname(marker), { recursive: true });
+  writeDurableFile(
+    marker,
+    `${JSON.stringify({ schema_version: 1, mode: "plugin", transaction_id: transactionId })}
+`,
+    { mode: 384 }
+  );
+}
+function unresolvedPaths(legacy) {
+  return [
+    ...legacy.conflictingFiles,
+    ...legacy.conflictingHooks.map(
+      (hook) => `.claude/settings.json#hooks.${hook.event}[${String(hook.index)}]`
+    ),
+    ...legacy.settingsError === void 0 ? [] : [".claude/settings.json"]
+  ];
+}
+function automaticAdvisory(paths) {
+  if (paths.length === 0) return void 0;
+  return `Safeword removed the old Claude integration it could verify, but preserved unrecognized content at ${paths.join(", ")}. Review those paths; your prompt was not blocked.`;
+}
+function recordAutomaticAttention(cwd, options, classification, advisory) {
+  writeClaudeMigrationAttention(cwd, {
+    schema_version: 1,
+    state_digest: advisoryStateDigest(advisory),
+    plugin_version: options.pluginVersion,
+    catalogue_sha256: options.catalogueSha256,
+    watched_settings_sha256: claudeWatchedSettingsDigest(cwd),
+    classification,
+    advisory
+  });
+}
+function waitForPluginMode(cwd, deadline, now) {
+  const marker = containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.pluginMarkerV2);
+  const pause = new Int32Array(new SharedArrayBuffer(4));
+  const maximumChecks = 25;
+  for (let checks = 0; checks < maximumChecks && now() < deadline; checks += 1) {
+    if (existsSync(marker)) return true;
+    const remaining = Math.max(1, deadline - now());
+    Atomics.wait(pause, 0, 0, Math.min(20, remaining));
+  }
+  return existsSync(marker);
+}
+function writeAutomaticPluginMode(cwd, transaction) {
+  const pluginMode = transaction.plugin_mode;
+  if (pluginMode === void 0) {
+    writePluginModeMarker(cwd, transaction.transaction_id);
+    return;
+  }
+  writeClaudePluginMode(
+    cwd,
+    createClaudePluginMode({
+      plugin_version: pluginMode.plugin_version,
+      hook_manifest_sha256: pluginMode.hook_manifest_sha256,
+      catalogue_sha256: pluginMode.catalogue_sha256,
+      unresolved_paths: pluginMode.unresolved_paths,
+      advisory: pluginMode.advisory,
+      transaction_id: transaction.transaction_id
+    })
+  );
+}
+function cleanupFailure(error, classification = "coexistence") {
+  return createResult({
+    state: "failed",
+    errors: [{ code: "CLAUDE_CLEANUP_FAILED", message: String(error), retryable: true }],
+    nextActions: [{ command: "safeword claude recover", mutates: true, requiresHuman: true }],
+    data: { command: "claude cleanup", classification }
+  });
+}
+function migrateClaudeLegacyAutomatically(cwd, options) {
+  const now = options.now ?? Date.now;
+  let projectRoot;
+  try {
+    projectRoot = canonicalClaudeProjectRoot(cwd);
+    return performAutomaticMigration(projectRoot, options, now);
+  } catch (error) {
+    const advisory = `Safeword preserved the old Claude integration after cleanup could not finish: ${error instanceof Error ? error.message : String(error)} Your prompt was not blocked; run \`safeword claude recover\` to repair it.`;
+    if (projectRoot !== void 0) {
+      try {
+        recordAutomaticAttention(projectRoot, options, "migration-error", advisory);
+      } catch {
+      }
+    }
+    return {
+      state: "attention",
+      advisory,
+      unresolvedPaths: []
+    };
+  }
+}
+function recoveredAutomaticResult(projectRoot) {
+  const recovered = recoverClaudeCleanup(projectRoot);
+  if (recovered.state !== "failed") return { state: "complete", unresolvedPaths: [] };
+  const detail = recovered.errors?.[0]?.message ?? "the recorded cleanup transaction could not be read safely";
+  return {
+    state: "attention",
+    advisory: `Safeword preserved the old Claude integration because automatic recovery could not finish: ${detail} Your prompt was not blocked; run \`safeword claude recover\` to repair it.`,
+    unresolvedPaths: []
+  };
+}
+function writeObservedPluginMode(projectRoot, options, unresolved, advisory) {
+  writeClaudePluginMode(
+    projectRoot,
+    createClaudePluginMode({
+      plugin_version: options.pluginVersion,
+      hook_manifest_sha256: options.hookManifestSha256,
+      catalogue_sha256: options.catalogueSha256,
+      unresolved_paths: unresolved,
+      advisory
+    })
+  );
+  return { state: "complete", advisory, unresolvedPaths: unresolved };
+}
+function claimAutomaticTransaction(projectRoot, transaction, options, now, unresolved) {
+  try {
+    writeTransaction(projectRoot, transaction);
+    return void 0;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    if (waitForPluginMode(projectRoot, options.deadline, now)) {
+      return { state: "complete", unresolvedPaths: unresolved };
+    }
+    return {
+      state: "deferred",
+      advisory: "Another Safeword process is retiring the old Claude integration. Your prompt was not blocked; the next prompt will verify that it finished.",
+      unresolvedPaths: unresolved
+    };
+  }
+}
+function concurrentMigrationResult(projectRoot, options, now) {
+  const concurrentDeadline = Math.min(options.deadline, now() + 500);
+  if (waitForPluginMode(projectRoot, concurrentDeadline, now)) {
+    return { state: "complete", unresolvedPaths: [] };
+  }
+  if (now() >= options.deadline) {
+    return {
+      state: "deferred",
+      advisory: "Another Safeword process is retiring the old Claude integration. Your prompt was not blocked; the next prompt will verify that it finished.",
+      unresolvedPaths: []
+    };
+  }
+  return recoveredAutomaticResult(projectRoot);
+}
+function planCleanupEntries(projectRoot, mutations) {
+  try {
+    return mutations.map((mutation) => entryFor(projectRoot, mutation));
+  } catch (error) {
+    if (existsSync(transactionPath(projectRoot))) return void 0;
+    throw error;
+  }
+}
+function performAutomaticMigration(projectRoot, options, now) {
+  if (now() >= options.deadline) {
+    return {
+      state: "deferred",
+      advisory: "Safeword deferred old Claude integration cleanup until the next prompt.",
+      unresolvedPaths: []
+    };
+  }
+  if (existsSync(transactionPath(projectRoot)))
+    return concurrentMigrationResult(projectRoot, options, now);
+  const legacy = observeClaudeLegacy(projectRoot);
+  const unresolved = unresolvedPaths(legacy);
+  const advisory = automaticAdvisory(unresolved);
+  const mutations = claudeLegacyMutations(projectRoot);
+  if (mutations.length === 0) {
+    return writeObservedPluginMode(projectRoot, options, unresolved, advisory);
+  }
+  const entries = planCleanupEntries(projectRoot, mutations);
+  if (entries === void 0) return concurrentMigrationResult(projectRoot, options, now);
+  const transaction = {
+    schema_version: 1,
+    transaction_id: randomUUID(),
+    disposition: "complete-forward",
+    entries,
+    plugin_mode: {
+      plugin_version: options.pluginVersion,
+      hook_manifest_sha256: options.hookManifestSha256,
+      catalogue_sha256: options.catalogueSha256,
+      unresolved_paths: unresolved,
+      advisory
+    }
+  };
+  const contention = claimAutomaticTransaction(projectRoot, transaction, options, now, unresolved);
+  if (contention !== void 0) return contention;
+  if (!applyEntries(projectRoot, transaction.entries, () => now() >= options.deadline)) {
+    return {
+      state: "deferred",
+      advisory: "Safeword will finish removing its old Claude integration on the next prompt.",
+      unresolvedPaths: unresolved
+    };
+  }
+  writeAutomaticPluginMode(projectRoot, transaction);
+  rmSync(transactionPath(projectRoot), { force: true });
+  return { state: "complete", advisory, unresolvedPaths: unresolved };
+}
+function parseTransaction(cwd) {
+  const value = JSON.parse(readFileSync(transactionPath(cwd), "utf8"));
+  if (value.schema_version !== 1 || !Array.isArray(value.entries))
+    throw new Error("Claude cleanup transaction is malformed.");
+  return value;
+}
+function pendingRecoveryEntries(projectRoot, transaction) {
+  const forward = transaction.disposition === "complete-forward";
+  const pending = [];
+  for (const entry of transaction.entries) {
+    const path = assertSafeClaudeCleanupTarget(projectRoot, entry.path);
+    const current = observedSha(path);
+    const source = forward ? entry.before_sha256 : entry.after_sha256;
+    const destination = forward ? entry.after_sha256 : entry.before_sha256;
+    if (current === destination) continue;
+    if (current !== source) throw new Error(`Claude recovery conflict at ${entry.path}`);
+    pending.push(entry);
+  }
+  return pending;
+}
+function applyRecoveryEntries(projectRoot, transaction, pending) {
+  const forward = transaction.disposition === "complete-forward";
+  for (const entry of pending) {
+    const path = containedClaudeCleanupPath(projectRoot, entry.path);
+    writeImage(
+      projectRoot,
+      path,
+      forward ? entry.after_base64 : entry.before_base64,
+      forward ? entry.after_mode : entry.before_mode
+    );
+  }
+}
+function completedRecoveryResult(projectRoot, transaction) {
+  if (transaction.disposition === "complete-forward") {
+    writeAutomaticPluginMode(projectRoot, transaction);
+  }
+  rmSync(transactionPath(projectRoot), { force: true });
+  return createResult({
+    state: "changed",
+    data: {
+      command: "claude recover",
+      classification: transaction.disposition === "complete-forward" ? "plugin-mode" : "cleanup-ready"
+    }
+  });
+}
+function recoverClaudeCleanup(cwd) {
+  let projectRoot;
+  try {
+    projectRoot = canonicalClaudeProjectRoot(cwd);
+  } catch (error) {
+    return cleanupFailure(error, "recovery-required");
+  }
+  if (!existsSync(transactionPath(projectRoot))) {
+    return createResult({
+      state: "healthy",
+      data: { command: "claude recover", classification: "plugin-mode" }
+    });
+  }
+  try {
+    const transaction = parseTransaction(projectRoot);
+    applyRecoveryEntries(
+      projectRoot,
+      transaction,
+      pendingRecoveryEntries(projectRoot, transaction)
+    );
+    return completedRecoveryResult(projectRoot, transaction);
+  } catch (error) {
+    return createResult({
+      state: "failed",
+      errors: [{ code: "CLAUDE_RECOVERY_CONFLICT", message: String(error), retryable: true }],
+      nextActions: [
+        { command: "resolve the reported recovery conflict", mutates: false, requiresHuman: true }
+      ],
+      data: { command: "claude recover", classification: "recovery-required" }
+    });
+  }
+}
+
+export {
+  claudeLegacyMutations,
+  claudeCleanupPreconditionDigest,
+  migrateClaudeLegacyAutomatically,
+  recoverClaudeCleanup
+};
+//# sourceMappingURL=chunk-4HQHVNDP.js.map

package/dist/chunk-4HQHVNDP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/claude-plugin/cleanup.ts"],"sourcesContent":["/* eslint-disable unicorn/no-null -- null is the versioned absent-file image */\n\nimport { createHash, randomUUID } from 'node:crypto';\nimport {\n  chmodSync,\n  existsSync,\n  lstatSync,\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  rmdirSync,\n  rmSync,\n} from 'node:fs';\nimport nodePath from 'node:path';\n\nimport { applyEdits, modify, parse, visit } from 'jsonc-parser';\n\nimport { type CliResult, createResult } from '../cli-protocol/result.js';\nimport { writeDurableFile, writeDurableFileExclusive } from '../codex-plugin/durable-write.js';\nimport { assertSafeClaudeCleanupTarget, containedClaudeCleanupPath } from './cleanup-target.js';\nimport { CLAUDE_MIGRATION_SCHEMA } from './inventory.js';\nimport { type ClaudeLegacyObservation, observeClaudeLegacy } from './legacy-classifier.js';\nimport {\n  advisoryStateDigest,\n  claudeWatchedSettingsDigest,\n  createClaudePluginMode,\n  writeClaudeMigrationAttention,\n  writeClaudePluginMode,\n} from './migration-state.js';\nimport { canonicalClaudeProjectRoot } from './project-root.js';\n\ninterface CleanupEntry {\n  readonly path: string;\n  readonly before_sha256: string;\n  readonly before_base64: string;\n  readonly before_mode: number;\n  readonly after_sha256: string | null;\n  readonly after_base64: string | null;\n  readonly after_mode: number | null;\n}\n\ninterface CleanupTransaction {\n  readonly schema_version: 1;\n  readonly transaction_id: string;\n  readonly disposition: 'complete-forward' | 'restore-backup';\n  readonly entries: CleanupEntry[];\n  readonly plugin_mode?: {\n    readonly plugin_version: string;\n    readonly hook_manifest_sha256: string;\n    readonly catalogue_sha256: string;\n    readonly unresolved_paths: readonly string[];\n    readonly advisory?: string;\n  };\n}\n\nexport interface AutomaticClaudeMigrationOptions {\n  readonly pluginVersion: string;\n  readonly hookManifestSha256: string;\n  readonly catalogueSha256: string;\n  readonly deadline: number;\n  readonly now?: () => number;\n}\n\nexport interface AutomaticClaudeMigrationResult {\n  readonly state: 'complete' | 'deferred' | 'attention';\n  readonly advisory?: string;\n  readonly unresolvedPaths: readonly string[];\n}\n\nfunction sha256(content: Buffer | string): string {\n  return createHash('sha256').update(content).digest('hex');\n}\n\nfunction containsJsonComments(content: string): boolean {\n  let found = false;\n  visit(content, { onComment: () => (found = true) });\n  return found;\n}\n\nfunction settingsMutation(\n  cwd: string,\n  legacy: ClaudeLegacyObservation,\n): { path: string; content: string | null } | undefined {\n  const relative = '.claude/settings.json';\n  const path = nodePath.join(cwd, relative);\n  if (!existsSync(path) || legacy.recognizedHooks.length === 0) return undefined;\n  const original = readFileSync(path, 'utf8');\n  const parsed = parse(original) as Record<string, unknown>;\n  const hooks = (parsed.hooks as Record<string, unknown[]> | undefined) ?? {};\n  const allHookValuesAreArrays = Object.values(hooks).every(entries => Array.isArray(entries));\n  const hookCount = Object.values(hooks).reduce(\n    (count, entries) => count + (Array.isArray(entries) ? entries.length : 0),\n    0,\n  );\n  const generatedHookOnlyFile =\n    Object.keys(parsed).length === 1 &&\n    allHookValuesAreArrays &&\n    hookCount === legacy.recognizedHooks.length &&\n    !containsJsonComments(original);\n  if (generatedHookOnlyFile) return { path: relative, content: null };\n\n  let content = original;\n  const references = legacy.recognizedHooks.toSorted((left, right) => {\n    const eventOrder = right.event.localeCompare(left.event);\n    return eventOrder === 0 ? right.index - left.index : eventOrder;\n  });\n  for (const reference of references) {\n    content = applyEdits(\n      content,\n      modify(content, ['hooks', reference.event, reference.index], undefined, {\n        formattingOptions: { insertSpaces: true, tabSize: 2 },\n      }),\n    );\n  }\n  return {\n    path: relative,\n    content,\n  };\n}\n\nexport function claudeLegacyMutations(cwd: string): { path: string; content: string | null }[] {\n  const legacy = observeClaudeLegacy(cwd);\n  const files: { path: string; content: string | null }[] = legacy.recognizedFiles.map(path => ({\n    path,\n    content: null,\n  }));\n  const settings = settingsMutation(cwd, legacy);\n  if (settings !== undefined) files.push(settings);\n  return files;\n}\n\nexport function claudeCleanupPreconditionDigest(\n  cwd: string,\n  mutations: readonly { path: string; content: string | null }[],\n): string {\n  return sha256(\n    JSON.stringify(\n      mutations.map(mutation => {\n        const target = assertSafeClaudeCleanupTarget(cwd, mutation.path);\n        return [mutation.path, sha256(readFileSync(target)), mutation.content];\n      }),\n    ),\n  );\n}\n\nfunction transactionPath(cwd: string): string {\n  return containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.transaction);\n}\n\nfunction writeTransaction(cwd: string, transaction: CleanupTransaction): void {\n  const path = transactionPath(cwd);\n  mkdirSync(nodePath.dirname(path), { recursive: true, mode: 0o700 });\n  writeDurableFileExclusive(path, `${JSON.stringify(transaction, undefined, 2)}\\n`, {\n    mode: 0o600,\n  });\n}\n\nfunction entryFor(cwd: string, mutation: { path: string; content: string | null }): CleanupEntry {\n  const path = assertSafeClaudeCleanupTarget(cwd, mutation.path);\n  const before = readFileSync(path);\n  const after = mutation.content === null ? null : Buffer.from(mutation.content);\n  return {\n    path: mutation.path,\n    before_sha256: sha256(before),\n    before_base64: before.toString('base64'),\n    before_mode: lstatSync(path).mode & 0o777,\n    after_sha256: after === null ? null : sha256(after),\n    after_base64: after === null ? null : after.toString('base64'),\n    after_mode: after === null ? null : lstatSync(path).mode & 0o777,\n  };\n}\n\nfunction observedSha(path: string): string | null {\n  return existsSync(path) ? sha256(readFileSync(path)) : null;\n}\n\n/**\n * Removes the directories a contracted file leaves behind. Legacy Claude\n * delivery is nested (`.claude/skills/<skill>/SKILL.md`), so deleting the files\n * alone strands a husk tree the user then has to clean up by hand. Pruning\n * stops at the first non-empty ancestor and never leaves the project root, so\n * it can only ever remove directories Safeword just emptied.\n */\nfunction pruneEmptyAncestors(root: string, path: string): void {\n  const canonicalRoot = nodePath.resolve(root);\n  let directory = nodePath.dirname(nodePath.resolve(path));\n  while (directory.startsWith(`${canonicalRoot}${nodePath.sep}`)) {\n    try {\n      if (readdirSync(directory).length > 0) return;\n      rmdirSync(directory);\n    } catch {\n      // A concurrent writer repopulated or removed the directory. The files\n      // Safeword owns are already gone, so the prompt must not fail for a husk.\n      return;\n    }\n    directory = nodePath.dirname(directory);\n  }\n}\n\nfunction writeImage(root: string, path: string, content: string | null, mode: number | null): void {\n  if (content === null) {\n    rmSync(path, { force: true });\n    pruneEmptyAncestors(root, path);\n    return;\n  }\n  mkdirSync(nodePath.dirname(path), { recursive: true });\n  writeDurableFile(path, Buffer.from(content, 'base64'), { mode: mode ?? 0o644 });\n  chmodSync(path, mode ?? 0o644);\n}\n\nfunction applyEntries(\n  cwd: string,\n  entries: readonly CleanupEntry[],\n  shouldDefer: () => boolean = () => false,\n): boolean {\n  for (const entry of entries) {\n    if (shouldDefer()) return false;\n    const path = assertSafeClaudeCleanupTarget(cwd, entry.path);\n    if (observedSha(path) !== entry.before_sha256) {\n      throw new Error(`Claude cleanup target changed after planning: ${entry.path}`);\n    }\n    writeImage(cwd, path, entry.after_base64, entry.after_mode);\n  }\n  return true;\n}\n\nfunction writePluginModeMarker(cwd: string, transactionId: string): void {\n  const marker = containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.pluginMarker);\n  mkdirSync(nodePath.dirname(marker), { recursive: true });\n  writeDurableFile(\n    marker,\n    `${JSON.stringify({ schema_version: 1, mode: 'plugin', transaction_id: transactionId })}\\n`,\n    { mode: 0o600 },\n  );\n}\n\nfunction unresolvedPaths(legacy: ClaudeLegacyObservation): string[] {\n  return [\n    ...legacy.conflictingFiles,\n    ...legacy.conflictingHooks.map(\n      hook => `.claude/settings.json#hooks.${hook.event}[${String(hook.index)}]`,\n    ),\n    ...(legacy.settingsError === undefined ? [] : ['.claude/settings.json']),\n  ];\n}\n\nfunction automaticAdvisory(paths: readonly string[]): string | undefined {\n  if (paths.length === 0) return undefined;\n  return `Safeword removed the old Claude integration it could verify, but preserved unrecognized content at ${paths.join(', ')}. Review those paths; your prompt was not blocked.`;\n}\n\nfunction recordAutomaticAttention(\n  cwd: string,\n  options: AutomaticClaudeMigrationOptions,\n  classification: string,\n  advisory: string,\n): void {\n  writeClaudeMigrationAttention(cwd, {\n    schema_version: 1,\n    state_digest: advisoryStateDigest(advisory),\n    plugin_version: options.pluginVersion,\n    catalogue_sha256: options.catalogueSha256,\n    watched_settings_sha256: claudeWatchedSettingsDigest(cwd),\n    classification,\n    advisory,\n  });\n}\n\nfunction waitForPluginMode(cwd: string, deadline: number, now: () => number): boolean {\n  const marker = containedClaudeCleanupPath(cwd, CLAUDE_MIGRATION_SCHEMA.paths.pluginMarkerV2);\n  const pause = new Int32Array(new SharedArrayBuffer(4));\n  const maximumChecks = 25;\n  for (let checks = 0; checks < maximumChecks && now() < deadline; checks += 1) {\n    if (existsSync(marker)) return true;\n    const remaining = Math.max(1, deadline - now());\n    Atomics.wait(pause, 0, 0, Math.min(20, remaining));\n  }\n  return existsSync(marker);\n}\n\nfunction writeAutomaticPluginMode(cwd: string, transaction: CleanupTransaction): void {\n  const pluginMode = transaction.plugin_mode;\n  if (pluginMode === undefined) {\n    writePluginModeMarker(cwd, transaction.transaction_id);\n    return;\n  }\n  writeClaudePluginMode(\n    cwd,\n    createClaudePluginMode({\n      plugin_version: pluginMode.plugin_version,\n      hook_manifest_sha256: pluginMode.hook_manifest_sha256,\n      catalogue_sha256: pluginMode.catalogue_sha256,\n      unresolved_paths: pluginMode.unresolved_paths,\n      advisory: pluginMode.advisory,\n      transaction_id: transaction.transaction_id,\n    }),\n  );\n}\n\nfunction cleanupFailure(error: unknown, classification = 'coexistence'): CliResult {\n  return createResult({\n    state: 'failed',\n    errors: [{ code: 'CLAUDE_CLEANUP_FAILED', message: String(error), retryable: true }],\n    nextActions: [{ command: 'safeword claude recover', mutates: true, requiresHuman: true }],\n    data: { command: 'claude cleanup', classification },\n  });\n}\n\nexport function migrateClaudeLegacyAutomatically(\n  cwd: string,\n  options: AutomaticClaudeMigrationOptions,\n): AutomaticClaudeMigrationResult {\n  const now = options.now ?? Date.now;\n  let projectRoot: string | undefined;\n  try {\n    projectRoot = canonicalClaudeProjectRoot(cwd);\n    return performAutomaticMigration(projectRoot, options, now);\n  } catch (error) {\n    const advisory = `Safeword preserved the old Claude integration after cleanup could not finish: ${error instanceof Error ? error.message : String(error)} Your prompt was not blocked; run \\`safeword claude recover\\` to repair it.`;\n    if (projectRoot !== undefined) {\n      try {\n        recordAutomaticAttention(projectRoot, options, 'migration-error', advisory);\n      } catch {\n        // The prompt must remain successful even when durable attention cannot be recorded.\n      }\n    }\n    return {\n      state: 'attention',\n      advisory,\n      unresolvedPaths: [],\n    };\n  }\n}\n\nfunction recoveredAutomaticResult(projectRoot: string): AutomaticClaudeMigrationResult {\n  const recovered = recoverClaudeCleanup(projectRoot);\n  if (recovered.state !== 'failed') return { state: 'complete', unresolvedPaths: [] };\n  const detail =\n    recovered.errors?.[0]?.message ?? 'the recorded cleanup transaction could not be read safely';\n  return {\n    state: 'attention',\n    advisory: `Safeword preserved the old Claude integration because automatic recovery could not finish: ${detail} Your prompt was not blocked; run \\`safeword claude recover\\` to repair it.`,\n    unresolvedPaths: [],\n  };\n}\n\nfunction writeObservedPluginMode(\n  projectRoot: string,\n  options: AutomaticClaudeMigrationOptions,\n  unresolved: readonly string[],\n  advisory: string | undefined,\n): AutomaticClaudeMigrationResult {\n  writeClaudePluginMode(\n    projectRoot,\n    createClaudePluginMode({\n      plugin_version: options.pluginVersion,\n      hook_manifest_sha256: options.hookManifestSha256,\n      catalogue_sha256: options.catalogueSha256,\n      unresolved_paths: unresolved,\n      advisory,\n    }),\n  );\n  return { state: 'complete', advisory, unresolvedPaths: unresolved };\n}\n\nfunction claimAutomaticTransaction(\n  projectRoot: string,\n  transaction: CleanupTransaction,\n  options: AutomaticClaudeMigrationOptions,\n  now: () => number,\n  unresolved: readonly string[],\n): AutomaticClaudeMigrationResult | undefined {\n  try {\n    writeTransaction(projectRoot, transaction);\n    return undefined;\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;\n    if (waitForPluginMode(projectRoot, options.deadline, now)) {\n      return { state: 'complete', unresolvedPaths: unresolved };\n    }\n    return {\n      state: 'deferred',\n      advisory:\n        'Another Safeword process is retiring the old Claude integration. Your prompt was not blocked; the next prompt will verify that it finished.',\n      unresolvedPaths: unresolved,\n    };\n  }\n}\n\n/** Defers to whichever process already claimed the cleanup transaction. */\nfunction concurrentMigrationResult(\n  projectRoot: string,\n  options: AutomaticClaudeMigrationOptions,\n  now: () => number,\n): AutomaticClaudeMigrationResult {\n  const concurrentDeadline = Math.min(options.deadline, now() + 500);\n  if (waitForPluginMode(projectRoot, concurrentDeadline, now)) {\n    return { state: 'complete', unresolvedPaths: [] };\n  }\n  if (now() >= options.deadline) {\n    return {\n      state: 'deferred',\n      advisory:\n        'Another Safeword process is retiring the old Claude integration. Your prompt was not blocked; the next prompt will verify that it finished.',\n      unresolvedPaths: [],\n    };\n  }\n  return recoveredAutomaticResult(projectRoot);\n}\n\n/**\n * Reads the before-images for a planned contraction.\n *\n * Planning happens before the exclusive transaction claim, so a process that\n * loses the race can be part-way through reading files the winner is already\n * deleting. That is an ordinary lost race, not a failure to report: returning\n * undefined routes it to the same deferral path as an already-claimed\n * transaction, instead of surfacing an ENOENT as a repair advisory.\n */\nfunction planCleanupEntries(\n  projectRoot: string,\n  mutations: readonly { path: string; content: string | null }[],\n): CleanupEntry[] | undefined {\n  try {\n    return mutations.map(mutation => entryFor(projectRoot, mutation));\n  } catch (error) {\n    if (existsSync(transactionPath(projectRoot))) return undefined;\n    throw error;\n  }\n}\n\nfunction performAutomaticMigration(\n  projectRoot: string,\n  options: AutomaticClaudeMigrationOptions,\n  now: () => number,\n): AutomaticClaudeMigrationResult {\n  if (now() >= options.deadline) {\n    return {\n      state: 'deferred',\n      advisory: 'Safeword deferred old Claude integration cleanup until the next prompt.',\n      unresolvedPaths: [],\n    };\n  }\n  if (existsSync(transactionPath(projectRoot)))\n    return concurrentMigrationResult(projectRoot, options, now);\n  const legacy = observeClaudeLegacy(projectRoot);\n  const unresolved = unresolvedPaths(legacy);\n  const advisory = automaticAdvisory(unresolved);\n  const mutations = claudeLegacyMutations(projectRoot);\n  if (mutations.length === 0) {\n    return writeObservedPluginMode(projectRoot, options, unresolved, advisory);\n  }\n  const entries = planCleanupEntries(projectRoot, mutations);\n  if (entries === undefined) return concurrentMigrationResult(projectRoot, options, now);\n  const transaction: CleanupTransaction = {\n    schema_version: 1,\n    transaction_id: randomUUID(),\n    disposition: 'complete-forward',\n    entries,\n    plugin_mode: {\n      plugin_version: options.pluginVersion,\n      hook_manifest_sha256: options.hookManifestSha256,\n      catalogue_sha256: options.catalogueSha256,\n      unresolved_paths: unresolved,\n      advisory,\n    },\n  };\n  const contention = claimAutomaticTransaction(projectRoot, transaction, options, now, unresolved);\n  if (contention !== undefined) return contention;\n  if (!applyEntries(projectRoot, transaction.entries, () => now() >= options.deadline)) {\n    return {\n      state: 'deferred',\n      advisory: 'Safeword will finish removing its old Claude integration on the next prompt.',\n      unresolvedPaths: unresolved,\n    };\n  }\n  writeAutomaticPluginMode(projectRoot, transaction);\n  rmSync(transactionPath(projectRoot), { force: true });\n  return { state: 'complete', advisory, unresolvedPaths: unresolved };\n}\n\nfunction parseTransaction(cwd: string): CleanupTransaction {\n  const value = JSON.parse(readFileSync(transactionPath(cwd), 'utf8')) as CleanupTransaction;\n  if (value.schema_version !== 1 || !Array.isArray(value.entries))\n    throw new Error('Claude cleanup transaction is malformed.');\n  return value;\n}\n\nfunction pendingRecoveryEntries(\n  projectRoot: string,\n  transaction: CleanupTransaction,\n): CleanupEntry[] {\n  const forward = transaction.disposition === 'complete-forward';\n  const pending: CleanupEntry[] = [];\n  for (const entry of transaction.entries) {\n    const path = assertSafeClaudeCleanupTarget(projectRoot, entry.path);\n    const current = observedSha(path);\n    const source = forward ? entry.before_sha256 : entry.after_sha256;\n    const destination = forward ? entry.after_sha256 : entry.before_sha256;\n    if (current === destination) continue;\n    if (current !== source) throw new Error(`Claude recovery conflict at ${entry.path}`);\n    pending.push(entry);\n  }\n  return pending;\n}\n\nfunction applyRecoveryEntries(\n  projectRoot: string,\n  transaction: CleanupTransaction,\n  pending: readonly CleanupEntry[],\n): void {\n  const forward = transaction.disposition === 'complete-forward';\n  for (const entry of pending) {\n    const path = containedClaudeCleanupPath(projectRoot, entry.path);\n    writeImage(\n      projectRoot,\n      path,\n      forward ? entry.after_base64 : entry.before_base64,\n      forward ? entry.after_mode : entry.before_mode,\n    );\n  }\n}\n\nfunction completedRecoveryResult(projectRoot: string, transaction: CleanupTransaction): CliResult {\n  if (transaction.disposition === 'complete-forward') {\n    writeAutomaticPluginMode(projectRoot, transaction);\n  }\n  rmSync(transactionPath(projectRoot), { force: true });\n  return createResult({\n    state: 'changed',\n    data: {\n      command: 'claude recover',\n      classification:\n        transaction.disposition === 'complete-forward' ? 'plugin-mode' : 'cleanup-ready',\n    },\n  });\n}\n\nexport function recoverClaudeCleanup(cwd: string): CliResult {\n  let projectRoot: string;\n  try {\n    projectRoot = canonicalClaudeProjectRoot(cwd);\n  } catch (error) {\n    return cleanupFailure(error, 'recovery-required');\n  }\n  if (!existsSync(transactionPath(projectRoot))) {\n    return createResult({\n      state: 'healthy',\n      data: { command: 'claude recover', classification: 'plugin-mode' },\n    });\n  }\n  try {\n    const transaction = parseTransaction(projectRoot);\n    applyRecoveryEntries(\n      projectRoot,\n      transaction,\n      pendingRecoveryEntries(projectRoot, transaction),\n    );\n    return completedRecoveryResult(projectRoot, transaction);\n  } catch (error) {\n    return createResult({\n      state: 'failed',\n      errors: [{ code: 'CLAUDE_RECOVERY_CONFLICT', message: String(error), retryable: true }],\n      nextActions: [\n        { command: 'resolve the reported recovery conflict', mutates: false, requiresHuman: true },\n      ],\n      data: { command: 'claude recover', classification: 'recovery-required' },\n    });\n  }\n}\n"],"mappings":"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","names":[]}