harnessed 4.5.1 → 4.7.0

package/dist/cli.mjs

@@ -38,7 +38,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "harnessed",
-      version: "4.5.1",
+      version: "4.7.0",
       description: "AI coding harness package manager + composition orchestrator",
       type: "module",
       license: "Apache-2.0",
@@ -852,10 +852,92 @@ var init_origin_check = __esm({
   "src/cli/lib/origin-check.ts"() {
   }
 });
-function getHarnessedRoot() {
+function claudeDescriptor(home = homedir()) {
+  const claudeHome = join(home, ".claude");
+  return {
+    id: "claude",
+    homeDir: claudeHome,
+    stateRoot: join(claudeHome, "harnessed"),
+    settingsPath: join(claudeHome, "settings.json"),
+    skillsDir: join(claudeHome, "skills"),
+    commandsDir: join(claudeHome, "commands"),
+    pluginsRegistry: join(claudeHome, "plugins", "installed_plugins.json"),
+    // mcpConfigPath is a SIBLING of `.claude` (`<home>/.claude.json`), based on
+    // the same home base — not a child of homeDir.
+    mcpConfigPath: join(home, ".claude.json"),
+    // claude writes its env keys into JSON settings.json (capability present).
+    supportsEnvKeyWrite: true
+  };
+}
+function codexDescriptor(home = homedir()) {
+  const codexHome = join(home, ".codex");
+  const configToml = join(codexHome, "config.toml");
+  return {
+    id: "codex",
+    homeDir: codexHome,
+    stateRoot: join(codexHome, "harnessed"),
+    settingsPath: configToml,
+    // SHARED convention dir, NOT <homeDir>/skills.
+    skillsDir: join(home, ".agents", "skills"),
+    commandsDir: join(codexHome, "prompts"),
+    pluginsRegistry: null,
+    mcpConfigPath: configToml,
+    supportsEnvKeyWrite: false
+  };
+}
+function descriptorById(id, home) {
+  if (id === "claude") return claudeDescriptor(home);
+  if (id === "codex") return codexDescriptor(home);
+  return void 0;
+}
+function detectPlatform(home = homedir()) {
+  const base = claudeDescriptor(home);
   const override = process.env.HARNESSED_ROOT_OVERRIDE;
-  if (override !== void 0 && override !== "") return override;
-  return join(homedir(), ".claude", "harnessed");
+  if (override !== void 0 && override !== "") return { ...base, stateRoot: override };
+  const envPlatform = process.env.HARNESSED_PLATFORM;
+  if (envPlatform !== void 0 && envPlatform !== "") {
+    const d = descriptorById(envPlatform, home);
+    if (d) return d;
+  }
+  try {
+    const pin = readFileSync(join(base.stateRoot, ".platform"), "utf8").trim();
+    const d = descriptorById(pin, home);
+    if (d) return d;
+  } catch {
+  }
+  try {
+    if (existsSync(base.homeDir)) return base;
+    const codex = codexDescriptor(home);
+    if (existsSync(codex.homeDir)) return codex;
+  } catch {
+  }
+  return base;
+}
+function getSettingsPath(home) {
+  return detectPlatform(home).settingsPath;
+}
+function getSkillsDir(home) {
+  return detectPlatform(home).skillsDir;
+}
+function getCommandsDir(home) {
+  return detectPlatform(home).commandsDir;
+}
+function getPluginsRegistry(home) {
+  return detectPlatform(home).pluginsRegistry;
+}
+function getMcpConfigPath(home) {
+  return detectPlatform(home).mcpConfigPath;
+}
+function harnessSkillsDirs(home) {
+  const dirs = [claudeDescriptor(home).skillsDir, codexDescriptor(home).skillsDir];
+  return [...new Set(dirs)];
+}
+var init_platform = __esm({
+  "src/installers/lib/platform.ts"() {
+  }
+});
+function getHarnessedRoot() {
+  return detectPlatform().stateRoot;
 }
 function harnessedSubdir(name) {
   return join(getHarnessedRoot(), name);
@@ -890,6 +972,7 @@ function migrateLegacyHarnessedRoot() {
 }
 var init_harnessedRoot = __esm({
   "src/installers/lib/harnessedRoot.ts"() {
+    init_platform();
   }
 });
 function getBackupRoot() {
@@ -1291,7 +1374,19 @@ var init_currentWorkflow_v1 = __esm({
             },
             { additionalProperties: false }
           )
-        )
+        ),
+        // Phase 22 — smart reminders. Additive-optional flags set by `checkpoint
+        // complete` (allResolved) and read by the G4 inject twins (booleans only; the
+        // bin computes neither git nor thresholds). Old files without them Value.Check-pass
+        // → NO schemaVersion bump.
+        //   ship_ready  — there are unshipped commits since the last vX.Y.Z tag (git-derived,
+        //                 recomputed each completion; self-heals to false after a release).
+        //   ship_commits — commit count since that tag (feeds the SHIP-READY hint text).
+        //   retro_due   — phases_since_retro (store sidecar) has crossed the threshold;
+        //                 cleared by `harnessed retro --done`.
+        ship_ready: Type.Optional(Type.Boolean()),
+        ship_commits: Type.Optional(Type.Integer({ minimum: 0 })),
+        retro_due: Type.Optional(Type.Boolean())
       },
       { additionalProperties: false }
     );
@@ -1309,6 +1404,7 @@ var init_schema2 = __esm({
 // src/checkpoint/workflowStore.ts
 var workflowStore_exports = {};
 __export(workflowStore_exports, {
+  RetroMetaEntry: () => RetroMetaEntry,
   WorkflowStoreV1: () => WorkflowStoreV1,
   listWorkflows: () => listWorkflows,
   readStoreRaw: () => readStoreRaw,
@@ -1369,17 +1465,26 @@ async function listWorkflows() {
     status: wf.status
   }));
 }
-var WorkflowStoreV1;
+var RetroMetaEntry, WorkflowStoreV1;
 var init_workflowStore = __esm({
   "src/checkpoint/workflowStore.ts"() {
     init_harnessedRoot();
     init_schemaVersion();
     init_atomicWrite();
     init_currentWorkflow_v1();
+    RetroMetaEntry = Type.Object(
+      {
+        phases_since_retro: Type.Integer({ minimum: 0 }),
+        last_retro_at: Type.Optional(Type.String({ minLength: 1 }))
+      },
+      { additionalProperties: false }
+    );
     WorkflowStoreV1 = Type.Object(
       {
         schemaVersion: Type.Literal(SCHEMA_VERSIONS.workflowStore),
-        workflows: Type.Record(Type.String(), CurrentWorkflowV1)
+        workflows: Type.Record(Type.String(), CurrentWorkflowV1),
+        // Additive-optional (no schemaVersion bump — old stores Value.Check-pass).
+        retro_meta: Type.Optional(Type.Record(Type.String(), RetroMetaEntry))
       },
       { additionalProperties: false }
     );
@@ -1393,6 +1498,7 @@ __export(state_exports, {
   WorkflowStateError: () => WorkflowStateError,
   activate: () => activate,
   complete: () => complete,
+  mutateStore: () => mutateStore,
   mutateSubProgress: () => mutateSubProgress,
   pause: () => pause,
   readCurrentWorkflow: () => readCurrentWorkflow,
@@ -1452,6 +1558,12 @@ async function mutateSubProgress(fn) {
     await writeCurrentWorkflowUnlocked({ ...s, sub_progress: next });
   });
 }
+async function mutateStore(fn) {
+  await withLock(async () => {
+    const store = await readStoreRaw();
+    await writeStoreRaw(fn(store));
+  });
+}
 async function activate(phase, checkpointPath = null) {
   await writeCurrentWorkflow({
     schemaVersion: SCHEMA_VERSIONS.currentWorkflow,
@@ -2027,7 +2139,7 @@ function nameToYamlHintPath(name) {
 function shouldOverwriteFile(content) {
   return HARNESSED_MARKER_RX.test(content) || V3_4_3_SIGNATURE_SUB_RX.test(content) || V3_4_3_SIGNATURE_MASTER_RX.test(content);
 }
-async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabilities, installedPlugins, installedUserSkills, writer, fileExists2 = existsSync, readFileSync12 = (p5) => readFileSync(p5, "utf8")) {
+async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabilities, installedPlugins, installedUserSkills, writer, fileExists2 = existsSync, readFileSync13 = (p5) => readFileSync(p5, "utf8")) {
   const results = [];
   const aggregatedWarnings = /* @__PURE__ */ new Set();
   for (const name of slashNames) {
@@ -2046,7 +2158,7 @@ async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabiliti
     if (fileExists2(path)) {
       let existing = "";
       try {
-        existing = readFileSync12(path);
+        existing = readFileSync13(path);
       } catch {
         existing = "";
       }
@@ -3801,6 +3913,91 @@ var init_compact = __esm({
   }
 });
 
+// src/checkpoint/shipReady.ts
+var shipReady_exports = {};
+__export(shipReady_exports, {
+  collectShipReady: () => collectShipReady,
+  defaultShipReady: () => defaultShipReady,
+  pickLatestReleaseTag: () => pickLatestReleaseTag
+});
+function pickLatestReleaseTag(tags) {
+  let best = null;
+  for (const tag of tags) {
+    const m = RELEASE_TAG.exec(tag.trim());
+    if (!m) continue;
+    const n = [Number(m[1]), Number(m[2]), Number(m[3])];
+    if (!best || n[0] > best.n[0] || n[0] === best.n[0] && n[1] > best.n[1] || n[0] === best.n[0] && n[1] === best.n[1] && n[2] > best.n[2]) {
+      best = { tag: tag.trim(), n };
+    }
+  }
+  return best?.tag ?? null;
+}
+function collectShipReady(tags, countSince) {
+  const baseTag = pickLatestReleaseTag(tags);
+  const commits = countSince(baseTag);
+  return { ready: commits > 0, commits, baseTag };
+}
+function defaultShipReady(cwd) {
+  let tags = [];
+  try {
+    tags = execFileSync("git", ["tag", "-l"], { cwd, encoding: "utf8" }).split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return { ready: false, commits: 0, baseTag: null };
+  }
+  const countSince = (tag) => {
+    try {
+      const range = tag ? `${tag}..HEAD` : "HEAD";
+      const out = execFileSync("git", ["rev-list", range, "--count"], {
+        cwd,
+        encoding: "utf8"
+      }).trim();
+      const n = Number(out);
+      return Number.isFinite(n) ? n : 0;
+    } catch {
+      return 0;
+    }
+  };
+  return collectShipReady(tags, countSince);
+}
+var RELEASE_TAG;
+var init_shipReady = __esm({
+  "src/checkpoint/shipReady.ts"() {
+    RELEASE_TAG = /^v(\d+)\.(\d+)\.(\d+)$/;
+  }
+});
+
+// src/checkpoint/retroMeta.ts
+var retroMeta_exports = {};
+__export(retroMeta_exports, {
+  DEFAULT_RETRO_THRESHOLD: () => DEFAULT_RETRO_THRESHOLD,
+  incrementPhases: () => incrementPhases,
+  isRetroDue: () => isRetroDue,
+  resetRetro: () => resetRetro,
+  retroThreshold: () => retroThreshold
+});
+function retroThreshold(env) {
+  const raw = env.HARNESSED_RETRO_PHASE_THRESHOLD;
+  if (raw === void 0) return DEFAULT_RETRO_THRESHOLD;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : DEFAULT_RETRO_THRESHOLD;
+}
+function incrementPhases(entry) {
+  if (!entry) return { phases_since_retro: 1 };
+  return entry.last_retro_at ? { phases_since_retro: entry.phases_since_retro + 1, last_retro_at: entry.last_retro_at } : { phases_since_retro: entry.phases_since_retro + 1 };
+}
+function isRetroDue(count, threshold) {
+  return count >= threshold;
+}
+function resetRetro(now) {
+  return { phases_since_retro: 0, last_retro_at: now };
+}
+var DEFAULT_RETRO_THRESHOLD;
+var init_retroMeta = __esm({
+  "src/checkpoint/retroMeta.ts"() {
+    DEFAULT_RETRO_THRESHOLD = 5;
+  }
+});
+
 // src/checkpoint/breakLoop.ts
 var breakLoop_exports = {};
 __export(breakLoop_exports, {
@@ -4259,7 +4456,7 @@ var init_check_mattpocock_skills = __esm({
   }
 });
 function getUserClaudeJsonPath() {
-  return join(homedir(), ".claude.json");
+  return getMcpConfigPath();
 }
 async function readUserClaudeJson() {
   const path = getUserClaudeJsonPath();
@@ -4285,21 +4482,20 @@ async function isMcpServerRegistered(name) {
   return Object.hasOwn(servers, name);
 }
 async function isPluginRegistered(pluginName) {
-  try {
-    const path = join(homedir(), ".claude", "plugins", "installed_plugins.json");
-    const raw = await readFile(path, "utf8");
-    const parsed = JSON.parse(raw);
-    const plugins = parsed.plugins;
-    if (plugins && typeof plugins === "object") {
-      if (Object.hasOwn(plugins, pluginName)) return true;
-      if (Object.keys(plugins).some((k) => k.split("@")[0] === pluginName)) return true;
+  const registryPath = getPluginsRegistry();
+  if (registryPath !== null) {
+    try {
+      const raw = await readFile(registryPath, "utf8");
+      const parsed = JSON.parse(raw);
+      const plugins = parsed.plugins;
+      if (plugins && typeof plugins === "object") {
+        if (Object.hasOwn(plugins, pluginName)) return true;
+        if (Object.keys(plugins).some((k) => k.split("@")[0] === pluginName)) return true;
+      }
+    } catch {
     }
-  } catch {
   }
-  for (const path of [
-    join(homedir(), ".claude", "settings.json"),
-    join(homedir(), ".claude.json")
-  ]) {
+  for (const path of [getSettingsPath(), getMcpConfigPath()]) {
     try {
       const raw = await readFile(path, "utf8");
       const parsed = JSON.parse(raw);
@@ -4315,6 +4511,7 @@ async function isPluginRegistered(pluginName) {
 }
 var init_readClaudeConfig = __esm({
   "src/installers/lib/readClaudeConfig.ts"() {
+    init_platform();
   }
 });
 
@@ -4713,6 +4910,7 @@ var init_ccHookAdd2 = __esm({
     init_confirm();
     init_diff();
     init_err();
+    init_platform();
     init_preflight();
     init_state2();
     installCcHookAdd = async (ctx) => {
@@ -4736,10 +4934,10 @@ var init_ccHookAdd2 = __esm({
         const e = pre.errors[0] ?? err(ctx, "/", "preflight failed", "preflight");
         return { ok: false, phase: "preflight", error: e };
       }
-      const settingsPath3 = join(homedir(), ".claude", "settings.json");
+      const settingsPath = getSettingsPath();
       let existing;
       try {
-        existing = await readFile(settingsPath3, "utf8");
+        existing = await readFile(settingsPath, "utf8");
       } catch {
         existing = null;
       }
@@ -4770,7 +4968,7 @@ var init_ccHookAdd2 = __esm({
       const newText = `${JSON.stringify(settings, null, 2)}
 `;
       const plan = {
-        files: [{ target: settingsPath3, scope: "HOME", oldText: existing ?? "", newText }]
+        files: [{ target: settingsPath, scope: "HOME", oldText: existing ?? "", newText }]
       };
       if (!ctx.opts.quiet) process.stdout.write(renderDiff(plan, ctx));
       const conf = await confirmAt("L3", { ...ctx});
@@ -4781,10 +4979,10 @@ var init_ccHookAdd2 = __esm({
       if (ctx.opts.dryRun) return { aborted: true, reason: "user-cancel" };
       const bk = await backup(plan, ctx);
       if (!bk.ok) return { ok: false, phase: "preflight", error: bk.error };
-      await writeFile(settingsPath3, newText);
+      await writeFile(settingsPath, newText);
       let verify;
       try {
-        verify = JSON.parse(await readFile(settingsPath3, "utf8"));
+        verify = JSON.parse(await readFile(settingsPath, "utf8"));
       } catch (e) {
         return {
           ok: false,
@@ -4812,7 +5010,7 @@ var init_ccHookAdd2 = __esm({
         };
       }
       await updateInstalled(ctx.cwd, ctx.manifest.metadata.name, "", "");
-      return { ok: true, backupId: bk.backupId, appliedFiles: [settingsPath3] };
+      return { ok: true, backupId: bk.backupId, appliedFiles: [settingsPath] };
     };
   }
 });
@@ -4868,10 +5066,10 @@ async function spawnCmd(ctx, cmd, args, timeoutMs, opts) {
   child.stderr?.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  return await new Promise((resolve20) => {
+  return await new Promise((resolve18) => {
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve20({
+      resolve18({
         ok: false,
         phase: "spawn",
         error: {
@@ -4887,7 +5085,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs, opts) {
     child.on("error", (err2) => {
       clearTimeout(timer);
       const bashMissing = triedBash && err2.code === "ENOENT";
-      resolve20({
+      resolve18({
         ok: false,
         phase: "spawn",
         error: {
@@ -4902,7 +5100,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs, opts) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve20({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
+      resolve18({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
     });
   });
 }
@@ -4942,7 +5140,7 @@ async function detectNative(ctx) {
   const indicators = INSTALLED_INDICATORS[name];
   if (indicators) {
     for (const ind of indicators) {
-      const dir = join(homedir(), ".claude", "skills", ind);
+      const dir = join(getSkillsDir(), ind);
       try {
         await access(dir);
         return true;
@@ -4961,8 +5159,8 @@ async function detectNative(ctx) {
   }
   if (method === "npx-skill-installer") {
     const skillName = extractSkillName(cmd, name);
-    for (const base of [".claude", ".agents"]) {
-      const skillMd = join(homedir(), base, "skills", skillName, "SKILL.md");
+    for (const skillsDir of harnessSkillsDirs()) {
+      const skillMd = join(skillsDir, skillName, "SKILL.md");
       try {
         await access(skillMd);
         return true;
@@ -4981,7 +5179,7 @@ async function detectNative(ctx) {
     }
   }
   if (method === "npm-cli") {
-    const skillDir = join(homedir(), ".claude", "skills", name);
+    const skillDir = join(getSkillsDir(), name);
     try {
       await access(skillDir);
       return true;
@@ -5015,6 +5213,7 @@ async function isAlreadyInstalled(ctx, opts = {}) {
 var IDEMPOTENT_CHECK_TIMEOUT_MS, INSTALLED_INDICATORS;
 var init_idempotent = __esm({
   "src/installers/lib/idempotent.ts"() {
+    init_platform();
     init_readClaudeConfig();
     init_spawn();
     IDEMPOTENT_CHECK_TIMEOUT_MS = 1e4;
@@ -5025,7 +5224,7 @@ var init_idempotent = __esm({
   }
 });
 function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve18) => {
     const isWin = process.platform === "win32";
     const child = isWin ? spawn("cmd.exe", ["/c", "claude", ...claudeArgs], { cwd, windowsHide: true }) : spawn("claude", claudeArgs, { cwd, shell: false });
     let stderr = "";
@@ -5034,15 +5233,15 @@ function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve20({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
+      resolve18({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
     }, timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve20({ exitCode: -1, stderr: `${stderr}${e.message}` });
+      resolve18({ exitCode: -1, stderr: `${stderr}${e.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve20({ exitCode: code ?? -1, stderr });
+      resolve18({ exitCode: code ?? -1, stderr });
     });
   });
 }
@@ -5212,7 +5411,7 @@ ${newEntry}
   }
 });
 function gitRevParseHead(cwd, timeoutMs = 1e4) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve18) => {
     const isWin = process.platform === "win32";
     const child = isWin ? spawn("cmd.exe", ["/c", "git", "rev-parse", "HEAD"], { cwd, windowsHide: true }) : spawn("git", ["rev-parse", "HEAD"], { cwd, shell: false });
     let stdout2 = "";
@@ -5221,15 +5420,15 @@ function gitRevParseHead(cwd, timeoutMs = 1e4) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve20({ sha: "", exit: -1 });
+      resolve18({ sha: "", exit: -1 });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve20({ sha: "", exit: -1 });
+      resolve18({ sha: "", exit: -1 });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve20({ sha: stdout2.trim(), exit: code ?? -1 });
+      resolve18({ sha: stdout2.trim(), exit: code ?? -1 });
     });
   });
 }
@@ -6170,8 +6369,14 @@ var init_install_base = __esm({
 // src/checkpoint/nextStep.ts
 var nextStep_exports = {};
 __export(nextStep_exports, {
+  resolveAutoTransition: () => resolveAutoTransition,
   resolveNext: () => resolveNext
 });
+function resolveAutoTransition(envelopeValue, env = process.env.HARNESSED_AUTO_TRANSITION) {
+  if (env === "true") return true;
+  if (env === "false") return false;
+  return envelopeValue ?? true;
+}
 function resolveNext(ledger, autoTransition) {
   const sub = nextPending(ledger);
   if (sub === null) return { next: "done" };
@@ -6768,7 +6973,7 @@ function renderHumanTable(records) {
   }
 }
 function pipeToJq(filterExpr, lines) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve18, reject) => {
     const child = spawn("jq", [filterExpr], {
       stdio: ["pipe", "inherit", "inherit"],
       windowsHide: true
@@ -6777,12 +6982,12 @@ function pipeToJq(filterExpr, lines) {
       const e = err2;
       if (e.code === "ENOENT") {
         console.error(t("audit_log.jq_missing"));
-        resolve20(1);
+        resolve18(1);
       } else {
         reject(err2);
       }
     });
-    child.on("close", (code) => resolve20(code ?? 0));
+    child.on("close", (code) => resolve18(code ?? 0));
     child.stdin.write(lines.join("\n"));
     child.stdin.end();
   });
@@ -6999,6 +7204,35 @@ function registerCheckpoint(program2) {
             );
           }
         }
+        if (allResolved) {
+          try {
+            const { defaultShipReady: defaultShipReady2 } = await Promise.resolve().then(() => (init_shipReady(), shipReady_exports));
+            const { incrementPhases: incrementPhases2, isRetroDue: isRetroDue2, retroThreshold: retroThreshold2 } = await Promise.resolve().then(() => (init_retroMeta(), retroMeta_exports));
+            const { mutateStore: mutateStore2, readCurrentWorkflow: readCurrentWorkflow4, writeCurrentWorkflow: writeCurrentWorkflow3 } = await Promise.resolve().then(() => (init_state(), state_exports));
+            const { repoKey: repoKey2 } = await Promise.resolve().then(() => (init_workflowStore(), workflowStore_exports));
+            const ship = defaultShipReady2(process.cwd());
+            const key = repoKey2();
+            const threshold = retroThreshold2(process.env);
+            let retroDue = false;
+            await mutateStore2((store) => {
+              const meta = { ...store.retro_meta ?? {} };
+              const next = incrementPhases2(meta[key]);
+              meta[key] = next;
+              retroDue = isRetroDue2(next.phases_since_retro, threshold);
+              return { ...store, retro_meta: meta };
+            });
+            const latest2 = await readCurrentWorkflow4();
+            if (latest2) {
+              await writeCurrentWorkflow3({
+                ...latest2,
+                ship_ready: ship.ready,
+                ship_commits: ship.commits,
+                retro_due: retroDue
+              });
+            }
+          } catch {
+          }
+        }
         console.log(`[harnessed] checkpoint complete: ${sub} (evidence: ${evidenceStatus})`);
         process.exit(0);
         return;
@@ -7315,24 +7549,26 @@ function registerInstall(program2) {
     const { resolveAlias: resolveAlias2 } = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
     const resolvedName = resolveAlias2(name) ?? name;
     checkPathSafe(resolvedName);
-    const manifestPath = resolve(getPackageRoot(), `manifests/tools/${resolvedName}.yaml`);
-    const skillPackPath = resolve(getPackageRoot(), `manifests/skill-packs/${resolvedName}.yaml`);
+    const candidatePaths = ["tools", "skill-packs", "optional"].map(
+      (dir) => resolve(getPackageRoot(), `manifests/${dir}/${resolvedName}.yaml`)
+    );
     let yamlSrc;
-    let chosenPath = manifestPath;
-    try {
-      yamlSrc = await readFile(manifestPath, "utf8");
-    } catch {
+    let chosenPath;
+    for (const p5 of candidatePaths) {
       try {
-        yamlSrc = await readFile(skillPackPath, "utf8");
-        chosenPath = skillPackPath;
+        yamlSrc = await readFile(p5, "utf8");
+        chosenPath = p5;
+        break;
       } catch {
-        console.error(
-          `${t("install.manifest_not_found", { name: resolvedName })}
-${t("install.manifest_not_found.fix", { name: resolvedName })}`
-        );
-        process.exit(1);
       }
     }
+    if (yamlSrc === void 0 || chosenPath === void 0) {
+      console.error(
+        `${t("install.manifest_not_found", { name: resolvedName })}
+${t("install.manifest_not_found.fix", { name: resolvedName })}`
+      );
+      process.exit(1);
+    }
     const v = validateManifestFile(yamlSrc, chosenPath);
     if (!v.ok) {
       for (const e of v.errors) console.error(`error: ${e.message} at ${e.path}`);
@@ -7392,6 +7628,181 @@ function registerLearn(program2) {
     process.exit(0);
   });
 }
+
+// src/cli/lib/here.ts
+init_nextStep();
+init_harnessedRoot();
+
+// src/cli/status.ts
+init_evidence();
+init_ledger();
+init_state();
+init_harnessedRoot();
+init_state2();
+function statusMarker(status) {
+  switch (status) {
+    case "done":
+      return "\u2705 done";
+    case "pending":
+      return "\u23F3 pending";
+    case "failed":
+      return "\u2717 failed";
+    case "skipped":
+      return "\u2B1C skipped";
+    case "rejected":
+      return "\u{1F6AB} rejected";
+  }
+}
+function evidenceLabel(entry) {
+  switch (entry.evidence_status) {
+    case "verified":
+      return "evidence: verified";
+    case "overridden":
+      return "evidence: overridden (--force)";
+    default:
+      return "evidence: none_declared";
+  }
+}
+async function buildRecoverLines(workflow, ledger) {
+  const lines = [];
+  if (!workflow || ledger.length === 0) {
+    lines.push("no ledger \u2014 run gates + start");
+    return lines;
+  }
+  lines.push(`workflow: ${workflow.phase} (${workflow.status})  started ${workflow.started_at}`);
+  const next = nextPending(ledger);
+  for (const e of ledger) {
+    const marker = statusMarker(e.status);
+    let suffix = "";
+    if (e.status === "skipped") {
+      suffix = e.reason ? `  (skipped: ${e.reason})` : "";
+    } else if (e.status === "done") {
+      suffix = `  ${evidenceLabel(e)}`;
+    }
+    const arrow = e.sub === next ? "   \u2190 next" : "";
+    lines.push(`  ${e.sub}  ${marker}${suffix}${arrow}`);
+  }
+  if (next) {
+    lines.push(`\u2192 next: harnessed prompt ${next}`);
+  } else {
+    lines.push("\u2192 all subs resolved (no pending work)");
+  }
+  for (const e of ledger) {
+    if (!e.evidence || e.evidence.length === 0) continue;
+    const drift = await detectDrift(e.evidence);
+    for (const d of drift) {
+      const now = d.now === "" ? "missing" : `${d.now.slice(0, 7)}\u2026`;
+      lines.push(`\u26A0 drift: ${d.path} sha256 changed (was ${d.was.slice(0, 7)}\u2026, now ${now})`);
+    }
+  }
+  return lines;
+}
+function registerStatus(program2) {
+  program2.command("status").description("Show installed upstreams (from <harnessed-root>/state.json)").option("--recover", "structured recovery view of the active workflow ledger (v5.0 Spec 1 B)").action(async (opts) => {
+    if (opts.recover) {
+      const wf = await readCurrentWorkflow();
+      const ledger = wf?.sub_progress ?? [];
+      const lines = await buildRecoverLines(wf, ledger);
+      for (const l of lines) console.log(l);
+      return;
+    }
+    const state = await readState(process.cwd());
+    const names = Object.keys(state.installed).sort();
+    if (names.length === 0) {
+      console.log(t("status.no_installs", { path: harnessedFile("state.json") }));
+    } else {
+      for (const n of names) {
+        const e = state.installed[n];
+        if (!e) continue;
+        console.log(`${n} @ ${e.version}  (installed ${e.installedAt})`);
+      }
+      console.log(t("status.summary_installs", { count: names.length }));
+    }
+    const lockPath = harnessedFile(".lock");
+    try {
+      const isLocked = await lockfile.check(getHarnessedRoot(), {
+        lockfilePath: lockPath,
+        stale: 1e4
+      });
+      if (isLocked) {
+        const s = await stat(lockPath);
+        const ageMs = Date.now() - s.mtime.getTime();
+        const stale = ageMs > 1e4;
+        console.log(
+          t("status.lock_held", {
+            since: s.mtime.toISOString(),
+            staleSuffix: stale ? t("status.lock_held.stale_suffix") : ""
+          })
+        );
+        console.log(t("status.lock_release_hint", { path: lockPath }));
+      } else {
+        console.log(t("status.lock_free"));
+      }
+    } catch {
+    }
+  });
+}
+
+// src/cli/lib/here.ts
+function parseBareInvocation(argvRest) {
+  const tokens = [];
+  for (let i = 0; i < argvRest.length; i++) {
+    const a = argvRest[i];
+    if (a === "--lang") {
+      i++;
+      continue;
+    }
+    if (a?.startsWith("--lang=")) continue;
+    if (a !== void 0) tokens.push(a);
+  }
+  if (tokens.length === 0) return { here: true, json: false };
+  if (tokens.length === 1 && tokens[0] === "--json") return { here: true, json: true };
+  return { here: false, json: false };
+}
+async function buildHereView(wf, ledger, auto) {
+  if (!wf) {
+    return {
+      lines: [
+        t("here.no_workflow", { path: harnessedFile("workflows.json") }),
+        t("here.no_workflow.hint")
+      ],
+      json: { active: false }
+    };
+  }
+  const body = await buildRecoverLines(wf, ledger);
+  const step = resolveNext(ledger, auto);
+  const lines = [
+    ...body,
+    `NEXT: ${step.next}`,
+    ...step.sub ? [`\u2192 run: harnessed prompt ${step.sub}`] : []
+  ];
+  return {
+    lines,
+    json: {
+      active: true,
+      phase: wf.phase,
+      status: wf.status,
+      started_at: wf.started_at,
+      next: step.next,
+      sub: step.sub,
+      hint: step.hint,
+      sub_progress: ledger
+    }
+  };
+}
+async function runHere(opts) {
+  const { readCurrentWorkflow: readCurrentWorkflow2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const wf = await readCurrentWorkflow2();
+  const ledger = wf?.sub_progress ?? [];
+  const auto = resolveAutoTransition(wf?.auto_transition);
+  const view = await buildHereView(wf, ledger, auto);
+  if (opts.json) {
+    console.log(JSON.stringify(view.json, null, 2));
+  } else {
+    for (const l of view.lines) console.log(l);
+  }
+  process.exit(0);
+}
 var QA = [
   { q: "\u2460 \u662F\u771F reusable surface \u8FD8\u662F\u4E34\u65F6 wrapper?", f: "q1_reusable_surface" },
   { q: "\u2461 \u4E0A\u6E38\u540D\u5B57 fit \u9879\u76EE shape \u5417? \u6709\u73B0\u6709\u547D\u540D\u51B2\u7A81\u5417?", f: "q2_name_fit" },
@@ -7445,21 +7856,15 @@ function registerManifestAdd(program2) {
 }
 
 // src/cli/next.ts
-function resolveAutoTransition(envelopeValue) {
-  const env = process.env.HARNESSED_AUTO_TRANSITION;
-  if (env === "true") return true;
-  if (env === "false") return false;
-  return envelopeValue ?? true;
-}
 function registerNext(program2) {
   program2.command("next").description(
     "Print the deterministic next-step contract (NEXT: auto|manual|done) for the active workflow"
   ).action(async () => {
     const { readCurrentWorkflow: readCurrentWorkflow2 } = await Promise.resolve().then(() => (init_state(), state_exports));
-    const { resolveNext: resolveNext2 } = await Promise.resolve().then(() => (init_nextStep(), nextStep_exports));
+    const { resolveNext: resolveNext2, resolveAutoTransition: resolveAutoTransition2 } = await Promise.resolve().then(() => (init_nextStep(), nextStep_exports));
     const current = await readCurrentWorkflow2();
     const ledger = current?.sub_progress ?? [];
-    const auto = resolveAutoTransition(current?.auto_transition);
+    const auto = resolveAutoTransition2(current?.auto_transition);
     const step = resolveNext2(ledger, auto);
     console.log(`NEXT: ${step.next}`);
     if (step.sub) console.log(`SUB: ${step.sub}`);
@@ -7743,6 +8148,37 @@ function registerResume(program2) {
     process.exit(0);
   });
 }
+
+// src/cli/retro.ts
+init_retroMeta();
+async function runRetroDone(now) {
+  const { mutateStore: mutateStore2, readCurrentWorkflow: readCurrentWorkflow2, writeCurrentWorkflow: writeCurrentWorkflow2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { repoKey: repoKey2 } = await Promise.resolve().then(() => (init_workflowStore(), workflowStore_exports));
+  const key = repoKey2();
+  await mutateStore2((store) => {
+    const meta = { ...store.retro_meta ?? {} };
+    meta[key] = resetRetro(now);
+    return { ...store, retro_meta: meta };
+  });
+  const wf = await readCurrentWorkflow2();
+  if (wf?.retro_due) await writeCurrentWorkflow2({ ...wf, retro_due: false });
+  return { reset: true };
+}
+function registerRetro(program2) {
+  program2.command("retro").description("Retro cadence: --done resets the phase counter after running /retro").option(
+    "--done",
+    "mark a retro as done \u2014 reset the phase counter + clear the RETRO-DUE reminder"
+  ).action(async (opts) => {
+    if (!opts.done) {
+      console.error("[harnessed] retro: nothing to do \u2014 pass --done after running /retro");
+      process.exit(1);
+      return;
+    }
+    await runRetroDone((/* @__PURE__ */ new Date()).toISOString());
+    console.log("[harnessed] retro recorded \u2014 phase counter reset, RETRO-DUE reminder cleared");
+    process.exit(0);
+  });
+}
 init_backup();
 function normalizeEol(buf, eol) {
   const lf = buf.toString("utf8").replace(/\r\n/g, "\n");
@@ -7814,9 +8250,13 @@ ${t("rollback.metadata_unreadable.fix")}`
 
 // src/cli.ts
 init_run2();
+init_platform();
+
+// src/cli/lib/capabilityResolver.ts
+init_platform();
 function readInstalledPlugins(homedirOverride) {
-  const home = homedir();
-  const path = join(home, ".claude", "plugins", "installed_plugins.json");
+  const path = getPluginsRegistry(homedirOverride);
+  if (path === null) return /* @__PURE__ */ new Set();
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -7841,8 +8281,7 @@ function readInstalledPlugins(homedirOverride) {
   return out;
 }
 function readInstalledUserSkills(homedirOverride) {
-  const home = homedir();
-  const skillsRoot = join(home, ".claude", "skills");
+  const skillsRoot = getSkillsDir(homedirOverride);
   try {
     const entries = readdirSync(skillsRoot, { withFileTypes: true });
     const out = /* @__PURE__ */ new Set();
@@ -7919,55 +8358,57 @@ function renderSkillBody(body, capabilities, installedPlugins, installedUserSkil
 }
 
 // src/cli/lib/enableAgentTeamsInSettings.ts
+init_platform();
+
+// src/cli/lib/settingsWriter.ts
 init_harnessedRoot();
-function settingsPath() {
-  return resolve(homedir(), ".claude", "settings.json");
-}
-async function enableAgentTeamsInSettings() {
-  const path = settingsPath();
+init_platform();
+async function mergeSettingsEnvKey(key, value, opts = {}) {
+  const path = getSettingsPath();
   let raw;
   try {
     raw = await readFile(path, "utf8");
   } catch (err2) {
     const code = err2.code;
     if (code !== "ENOENT") {
-      return { status: "warn", message: `read ${path} failed: ${err2.message}` };
+      return { outcome: "warn", message: `read ${path} failed: ${err2.message}` };
     }
-    return createFreshSettings(path);
+    return createFresh(path, key, value);
   }
   let data;
   try {
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { status: "warn", message: `${path} is not a JSON object` };
+      return { outcome: "warn", message: `${path} is not a JSON object` };
     }
     data = parsed;
   } catch (err2) {
-    return { status: "warn", message: `${path} malformed JSON: ${err2.message}` };
+    return { outcome: "warn", message: `${path} malformed JSON: ${err2.message}` };
   }
   const env = data.env ?? {};
-  if (env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1") {
-    return { status: "already-enabled", path };
+  const existing = env[key];
+  if (typeof existing === "string" && existing.length > 0 && opts.skipIfPresent?.(existing) === true) {
+    return { outcome: "already", path, existing };
   }
-  const backupPath = await backupOriginal(raw);
-  if (backupPath.status === "warn") return backupPath;
-  data.env = { ...env, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" };
+  const backup2 = await backupOriginal(raw);
+  if (backup2.status === "warn") return { outcome: "warn", message: backup2.message };
+  data.env = { ...env, [key]: value };
   const writeErr = await atomicWrite(path, `${JSON.stringify(data, null, 2)}
 `);
-  if (writeErr) return { status: "warn", message: writeErr };
-  return { status: "enabled", path, backupPath: backupPath.path };
+  if (writeErr) return { outcome: "warn", message: writeErr };
+  return { outcome: "merged", path, backupPath: backup2.path };
 }
-async function createFreshSettings(path) {
-  const data = { env: { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" } };
+async function createFresh(path, key, value) {
+  const data = { env: { [key]: value } };
   try {
-    await mkdir(join(homedir(), ".claude"), { recursive: true });
+    await mkdir(dirname(path), { recursive: true });
   } catch (err2) {
-    return { status: "warn", message: `mkdir ~/.claude failed: ${err2.message}` };
+    return { outcome: "warn", message: `mkdir ~/.claude failed: ${err2.message}` };
   }
   const writeErr = await atomicWrite(path, `${JSON.stringify(data, null, 2)}
 `);
-  if (writeErr) return { status: "warn", message: writeErr };
-  return { status: "created", path };
+  if (writeErr) return { outcome: "warn", message: writeErr };
+  return { outcome: "created", path };
 }
 async function backupOriginal(raw) {
   const backupRoot = harnessedSubdir("backups");
@@ -7992,11 +8433,34 @@ async function atomicWrite(path, content) {
   }
 }
 
-// src/cli/lib/enableUserLangInSettings.ts
-init_harnessedRoot();
-function settingsPath2() {
-  return resolve(homedir(), ".claude", "settings.json");
+// src/cli/lib/enableAgentTeamsInSettings.ts
+var ENV_KEY = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS";
+async function enableAgentTeamsInSettings() {
+  const platform = detectPlatform();
+  if (!platform.supportsEnvKeyWrite) {
+    return {
+      status: "warn",
+      message: `platform '${platform.id}' does not support env-key settings writes (capability-absent) \u2014 ${ENV_KEY} skipped`
+    };
+  }
+  const r = await mergeSettingsEnvKey(ENV_KEY, "1", {
+    skipIfPresent: (existing) => existing === "1"
+  });
+  switch (r.outcome) {
+    case "created":
+      return { status: "created", path: r.path };
+    case "already":
+      return { status: "already-enabled", path: r.path };
+    case "merged":
+      return { status: "enabled", path: r.path, backupPath: r.backupPath };
+    case "warn":
+      return { status: "warn", message: r.message };
+  }
 }
+
+// src/cli/lib/enableUserLangInSettings.ts
+init_platform();
+var ENV_KEY2 = "HARNESSED_USER_LANG";
 function detectUserLang(override) {
   if (override) {
     if (/^zh([^a-z]|$)/i.test(override)) return "zh-Hans";
@@ -8014,73 +8478,26 @@ function safeIntlLocale2() {
   }
 }
 async function enableUserLangInSettings(override) {
-  const path = settingsPath2();
-  const detected = detectUserLang(override);
-  let raw;
-  try {
-    raw = await readFile(path, "utf8");
-  } catch (err2) {
-    const code = err2.code;
-    if (code !== "ENOENT") {
-      return { status: "warn", message: `read ${path} failed: ${err2.message}` };
-    }
-    return createFreshSettings2(path, detected);
-  }
-  let data;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { status: "warn", message: `${path} is not a JSON object` };
-    }
-    data = parsed;
-  } catch (err2) {
-    return { status: "warn", message: `${path} malformed JSON: ${err2.message}` };
-  }
-  const env = data.env ?? {};
-  const existing = env.HARNESSED_USER_LANG;
-  if (typeof existing === "string" && existing.length > 0 && override === void 0) {
-    return { status: "already-set", path, existing };
-  }
-  const backupPath = await backupOriginal2(raw);
-  if (backupPath.status === "warn") return backupPath;
-  data.env = { ...env, HARNESSED_USER_LANG: detected };
-  const writeErr = await atomicWrite2(path, `${JSON.stringify(data, null, 2)}
-`);
-  if (writeErr) return { status: "warn", message: writeErr };
-  return { status: "enabled", path, backupPath: backupPath.path, detected };
-}
-async function createFreshSettings2(path, detected) {
-  const data = { env: { HARNESSED_USER_LANG: detected } };
-  try {
-    await mkdir(join(homedir(), ".claude"), { recursive: true });
-  } catch (err2) {
-    return { status: "warn", message: `mkdir ~/.claude failed: ${err2.message}` };
-  }
-  const writeErr = await atomicWrite2(path, `${JSON.stringify(data, null, 2)}
-`);
-  if (writeErr) return { status: "warn", message: writeErr };
-  return { status: "created", path, detected };
-}
-async function backupOriginal2(raw) {
-  const backupRoot = harnessedSubdir("backups");
-  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
-  const backupPath = join(backupRoot, `settings.json.${ts}.bak`);
-  try {
-    await mkdir(backupRoot, { recursive: true });
-    await writeFile(backupPath, raw, "utf8");
-    return { status: "ok", path: backupPath };
-  } catch (err2) {
-    return { status: "warn", message: `backup ${backupPath} failed: ${err2.message}` };
+  const platform = detectPlatform();
+  if (!platform.supportsEnvKeyWrite) {
+    return {
+      status: "warn",
+      message: `platform '${platform.id}' does not support env-key settings writes (capability-absent) \u2014 ${ENV_KEY2} skipped`
+    };
   }
-}
-async function atomicWrite2(path, content) {
-  const tmpPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    await writeFile(tmpPath, content, "utf8");
-    await rename(tmpPath, path);
-    return void 0;
-  } catch (err2) {
-    return `write ${path} failed: ${err2.message}`;
+  const detected = detectUserLang(override);
+  const r = await mergeSettingsEnvKey(ENV_KEY2, detected, {
+    skipIfPresent: () => override === void 0
+  });
+  switch (r.outcome) {
+    case "created":
+      return { status: "created", path: r.path, detected };
+    case "already":
+      return { status: "already-set", path: r.path, existing: r.existing };
+    case "merged":
+      return { status: "enabled", path: r.path, backupPath: r.backupPath, detected };
+    case "warn":
+      return { status: "warn", message: r.message };
   }
 }
 
@@ -8140,8 +8557,8 @@ async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOver
       ]
     };
   }
-  const installedPlugins = readInstalledPlugins();
-  const installedUserSkills = readInstalledUserSkills();
+  const installedPlugins = readInstalledPlugins(homedirOverride);
+  const installedUserSkills = readInstalledUserSkills(homedirOverride);
   const results = [];
   const warningSet = /* @__PURE__ */ new Set();
   for (const name of skillNames) {
@@ -8304,6 +8721,23 @@ async function runStepBInstall(manifestPaths, runOpts = {}) {
 }
 
 // src/cli/setup.ts
+var KNOWN_PLATFORMS = ["claude", "codex"];
+async function applyPlatformOption(platform) {
+  if (!KNOWN_PLATFORMS.includes(platform)) {
+    console.error(
+      `--platform: unknown id '${platform}' (expected one of: ${KNOWN_PLATFORMS.join(" | ")})`
+    );
+    process.exit(1);
+  }
+  process.env.HARNESSED_PLATFORM = platform;
+  const stateRoot = detectPlatform().stateRoot;
+  try {
+    await mkdir(stateRoot, { recursive: true });
+    await writeFile(join(stateRoot, ".platform"), platform, "utf8");
+  } catch (e) {
+    console.warn(`  [--platform] could not persist .platform pin (${e.message})`);
+  }
+}
 async function listBaseManifests2(pkgRoot) {
   const out = [];
   for (const d of ["manifests/tools", "manifests/skill-packs"]) {
@@ -8356,14 +8790,15 @@ function registerSetup(program2) {
   ).option("--dry-run", "preview only \u2014 do not write to disk (opt-in for advanced users)").option(
     "--user-lang <code>",
     "override detected OS locale for env.HARNESSED_USER_LANG (en | zh-Hans / zh-CN / zh-TW)"
-  ).option("--non-interactive", "skip all confirm prompts (CI / scripted setup)").option("--no-auto-install", "do not prompt to auto-install missing plugins (advisory only)").option(
+  ).option("--platform <id>", "target harness platform (claude | codex); default: auto-detect").option("--non-interactive", "skip all confirm prompts (CI / scripted setup)").option("--no-auto-install", "do not prompt to auto-install missing plugins (advisory only)").option(
     "--update-installed",
     "force re-install already-installed plugins (excludes MCP servers); default: skip if installed"
   ).action(async (raw) => {
     const dryRun = raw.dryRun === true;
+    if (raw.platform !== void 0) await applyPlatformOption(raw.platform);
     const pkgRoot = getPackageRoot();
     const workflowsDir = resolve(pkgRoot, "workflows");
-    const skillsBase = resolve(homedir(), ".claude", "skills");
+    const skillsBase = getSkillsDir();
     await warnIfAgentTeamsMissing();
     let entries;
     try {
@@ -8407,7 +8842,7 @@ function registerSetup(program2) {
         console.warn(`    - ${w}`);
       }
     }
-    const commandsBase = resolve(homedir(), ".claude", "commands");
+    const commandsBase = getCommandsDir();
     try {
       await mkdir(commandsBase, { recursive: true });
     } catch (e) {
@@ -8502,116 +8937,6 @@ Force-update pass complete: ${b2.installed.length} installed / ${b2.alreadyInsta
     process.exit(0);
   });
 }
-
-// src/cli/status.ts
-init_evidence();
-init_ledger();
-init_state();
-init_harnessedRoot();
-init_state2();
-function statusMarker(status) {
-  switch (status) {
-    case "done":
-      return "\u2705 done";
-    case "pending":
-      return "\u23F3 pending";
-    case "failed":
-      return "\u2717 failed";
-    case "skipped":
-      return "\u2B1C skipped";
-    case "rejected":
-      return "\u{1F6AB} rejected";
-  }
-}
-function evidenceLabel(entry) {
-  switch (entry.evidence_status) {
-    case "verified":
-      return "evidence: verified";
-    case "overridden":
-      return "evidence: overridden (--force)";
-    default:
-      return "evidence: none_declared";
-  }
-}
-async function buildRecoverLines(workflow, ledger) {
-  const lines = [];
-  if (!workflow || ledger.length === 0) {
-    lines.push("no ledger \u2014 run gates + start");
-    return lines;
-  }
-  lines.push(`workflow: ${workflow.phase} (${workflow.status})  started ${workflow.started_at}`);
-  const next = nextPending(ledger);
-  for (const e of ledger) {
-    const marker = statusMarker(e.status);
-    let suffix = "";
-    if (e.status === "skipped") {
-      suffix = e.reason ? `  (skipped: ${e.reason})` : "";
-    } else if (e.status === "done") {
-      suffix = `  ${evidenceLabel(e)}`;
-    }
-    const arrow = e.sub === next ? "   \u2190 next" : "";
-    lines.push(`  ${e.sub}  ${marker}${suffix}${arrow}`);
-  }
-  if (next) {
-    lines.push(`\u2192 next: harnessed prompt ${next}`);
-  } else {
-    lines.push("\u2192 all subs resolved (no pending work)");
-  }
-  for (const e of ledger) {
-    if (!e.evidence || e.evidence.length === 0) continue;
-    const drift = await detectDrift(e.evidence);
-    for (const d of drift) {
-      const now = d.now === "" ? "missing" : `${d.now.slice(0, 7)}\u2026`;
-      lines.push(`\u26A0 drift: ${d.path} sha256 changed (was ${d.was.slice(0, 7)}\u2026, now ${now})`);
-    }
-  }
-  return lines;
-}
-function registerStatus(program2) {
-  program2.command("status").description("Show installed upstreams (from <harnessed-root>/state.json)").option("--recover", "structured recovery view of the active workflow ledger (v5.0 Spec 1 B)").action(async (opts) => {
-    if (opts.recover) {
-      const wf = await readCurrentWorkflow();
-      const ledger = wf?.sub_progress ?? [];
-      const lines = await buildRecoverLines(wf, ledger);
-      for (const l of lines) console.log(l);
-      return;
-    }
-    const state = await readState(process.cwd());
-    const names = Object.keys(state.installed).sort();
-    if (names.length === 0) {
-      console.log(t("status.no_installs", { path: harnessedFile("state.json") }));
-    } else {
-      for (const n of names) {
-        const e = state.installed[n];
-        if (!e) continue;
-        console.log(`${n} @ ${e.version}  (installed ${e.installedAt})`);
-      }
-      console.log(t("status.summary_installs", { count: names.length }));
-    }
-    const lockPath = harnessedFile(".lock");
-    try {
-      const isLocked = await lockfile.check(getHarnessedRoot(), {
-        lockfilePath: lockPath,
-        stale: 1e4
-      });
-      if (isLocked) {
-        const s = await stat(lockPath);
-        const ageMs = Date.now() - s.mtime.getTime();
-        const stale = ageMs > 1e4;
-        console.log(
-          t("status.lock_held", {
-            since: s.mtime.toISOString(),
-            staleSuffix: stale ? t("status.lock_held.stale_suffix") : ""
-          })
-        );
-        console.log(t("status.lock_release_hint", { path: lockPath }));
-      } else {
-        console.log(t("status.lock_free"));
-      }
-    } catch {
-    }
-  });
-}
 init_harnessedRoot();
 init_path_guard();
 init_validate();
@@ -8630,10 +8955,10 @@ var uninstallCcHookAdd = async (ctx) => {
   }
   const abort = dryRunGate(ctx);
   if (abort) return abort;
-  const settingsPath3 = join(homedir(), ".claude", "settings.json");
+  const settingsPath = join(homedir(), ".claude", "settings.json");
   let existing;
   try {
-    existing = await readFile(settingsPath3, "utf8");
+    existing = await readFile(settingsPath, "utf8");
   } catch {
     return { ok: true, removedPaths: [] };
   }
@@ -8662,8 +8987,8 @@ var uninstallCcHookAdd = async (ctx) => {
   if (settings.hooks?.[ev]?.length === before || before === settings.hooks?.[ev]?.length) ;
   const newText = `${JSON.stringify(settings, null, 2)}
 `;
-  await writeFile(settingsPath3, newText);
-  return { ok: true, removedPaths: [settingsPath3] };
+  await writeFile(settingsPath, newText);
+  return { ok: true, removedPaths: [settingsPath] };
 };
 
 // src/uninstallers/ccPluginMarketplace.ts
@@ -8802,7 +9127,7 @@ var uninstallNpmCli = async (ctx) => {
   const m = install.cmd.match(/npm\s+(?:install|i)\s+(?:-g\s+)?(\S+)/);
   const pkg = m?.[1] ?? ctx.manifest.metadata.upstream.source;
   const isWin = process.platform === "win32";
-  const result = await new Promise((resolve20) => {
+  const result = await new Promise((resolve18) => {
     const child = isWin ? spawn("cmd.exe", ["/c", "npm", "uninstall", "-g", pkg], { windowsHide: true }) : spawn("npm", ["uninstall", "-g", pkg], { shell: false });
     let stderr = "";
     child.stderr?.setEncoding("utf8").on("data", (c) => {
@@ -8810,15 +9135,15 @@ var uninstallNpmCli = async (ctx) => {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve20({ exitCode: -1, stderr: `${stderr}[timeout]` });
+      resolve18({ exitCode: -1, stderr: `${stderr}[timeout]` });
     }, 3e4);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve20({ exitCode: -1, stderr: e.message });
+      resolve18({ exitCode: -1, stderr: e.message });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve20({ exitCode: code ?? -1, stderr });
+      resolve18({ exitCode: code ?? -1, stderr });
     });
   });
   if (result.exitCode !== 0) {
@@ -8884,9 +9209,9 @@ async function discoverCommandFiles(commandsDir) {
   }
   return owned;
 }
-async function checkSettingsEnv(settingsPath3) {
+async function checkSettingsEnv(settingsPath) {
   try {
-    const raw = await readFile(settingsPath3, "utf8");
+    const raw = await readFile(settingsPath, "utf8");
     const data = JSON.parse(raw);
     const env = data.env ?? {};
     return {
@@ -8897,8 +9222,8 @@ async function checkSettingsEnv(settingsPath3) {
     return { hasAgentTeams: false, hasUserLang: false };
   }
 }
-async function removeSettingsEnv(settingsPath3) {
-  const raw = await readFile(settingsPath3, "utf8");
+async function removeSettingsEnv(settingsPath) {
+  const raw = await readFile(settingsPath, "utf8");
   const data = JSON.parse(raw);
   const env = data.env ?? {};
   let changed = false;
@@ -8913,14 +9238,14 @@ async function removeSettingsEnv(settingsPath3) {
   if (!changed) return false;
   if (Object.keys(env).length === 0) delete data.env;
   else data.env = env;
-  await writeFile(settingsPath3, `${JSON.stringify(data, null, 2)}
+  await writeFile(settingsPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   return true;
 }
 async function runUnifiedUninstall(home, dryRun) {
   const commandsDir = join(home, ".claude", "commands");
   const skillsDir = join(home, ".claude", "skills");
-  const settingsPath3 = join(home, ".claude", "settings.json");
+  const settingsPath = join(home, ".claude", "settings.json");
   const harnessedRoot = getHarnessedRoot();
   const pkgRoot = getPackageRoot();
   let workflowNames = [];
@@ -8931,7 +9256,7 @@ async function runUnifiedUninstall(home, dryRun) {
   } catch {
   }
   const commandFiles = await discoverCommandFiles(commandsDir);
-  const settingsEnv = await checkSettingsEnv(settingsPath3);
+  const settingsEnv = await checkSettingsEnv(settingsPath);
   const hasSettingsChanges = settingsEnv.hasAgentTeams || settingsEnv.hasUserLang;
   const skillDirs = [];
   for (const name of workflowNames) {
@@ -8989,9 +9314,9 @@ async function runUnifiedUninstall(home, dryRun) {
   let removedSettings = false;
   if (hasSettingsChanges) {
     try {
-      removedSettings = await removeSettingsEnv(settingsPath3);
+      removedSettings = await removeSettingsEnv(settingsPath);
     } catch (e) {
-      failures.push(`${settingsPath3}: ${e.message}`);
+      failures.push(`${settingsPath}: ${e.message}`);
     }
   }
   const normalizedRoot = resolve(harnessedRoot);
@@ -9238,6 +9563,12 @@ registerWorkflows(program);
 registerLearn(program);
 registerUpdate(program);
 registerReleasePreflight(program);
-program.parse(process.argv);
+registerRetro(program);
+var bare = parseBareInvocation(process.argv.slice(2));
+if (bare.here) {
+  void runHere({ json: bare.json });
+} else {
+  program.parse(process.argv);
+}
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map