harnessed 4.6.0 → 4.8.0

package/dist/cli.mjs

@@ -6,6 +6,7 @@ import * as ajvFormatsNs from 'ajv-formats';
 import { execFileSync, spawnSync, spawn, exec, execFile, execSync } from 'child_process';
 import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, readdirSync } from 'fs';
 import { join, dirname, resolve, sep, relative } from 'path';
+import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
 import { readFile, readdir, unlink, writeFile, stat, rm, cp, mkdir, rename, appendFile, access } from 'fs/promises';
@@ -13,7 +14,6 @@ import { Value } from '@sinclair/typebox/value';
 import lockfile from 'proper-lockfile';
 import { Parser } from 'expr-eval';
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { fileURLToPath } from 'url';
 import { promisify } from 'util';
 import * as p from '@clack/prompts';
 import { createPatch } from 'diff';
@@ -38,7 +38,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "harnessed",
-      version: "4.6.0",
+      version: "4.8.0",
       description: "AI coding harness package manager + composition orchestrator",
       type: "module",
       license: "Apache-2.0",
@@ -852,10 +852,162 @@ var init_origin_check = __esm({
   "src/cli/lib/origin-check.ts"() {
   }
 });
-function getHarnessedRoot() {
+function mapToSupported(raw) {
+  if (!raw) return "en";
+  if (/^zh([^a-z]|$)/i.test(raw)) return "zh-Hans";
+  return "en";
+}
+function detectLocale() {
+  const raw = process.env.HARNESSED_LANG || process.env.LC_ALL || process.env.LANG || process.env.LANGUAGE || safeIntlLocale();
+  return mapToSupported(raw);
+}
+function safeIntlLocale() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale;
+  } catch {
+    return void 0;
+  }
+}
+function messagesDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [resolve(here, "..", "..", "messages"), resolve(here, "..", "messages")];
+  for (const c of candidates) {
+    try {
+      readFileSync(join(c, "en.json"), "utf8");
+      return c;
+    } catch {
+    }
+  }
+  return resolve(process.cwd(), "messages");
+}
+function loadLocale(locale) {
+  if (cache[locale]) return cache[locale];
+  const path = join(messagesDir(), `${locale}.json`);
+  try {
+    const raw = readFileSync(path, "utf8");
+    cache[locale] = JSON.parse(raw);
+  } catch {
+    cache[locale] = {};
+  }
+  return cache[locale];
+}
+function setLocale(locale) {
+  if (!locale) return;
+  const mapped = mapToSupported(locale);
+  if (SUPPORTED.has(mapped)) currentLocale = mapped;
+}
+function getLocale() {
+  if (currentLocale === null) currentLocale = detectLocale();
+  return currentLocale;
+}
+function t(key, params) {
+  const locale = getLocale();
+  const primary = loadLocale(locale);
+  let template = primary[key];
+  if (template === void 0 && locale !== "en") {
+    template = loadLocale("en")[key];
+  }
+  if (template === void 0) template = key;
+  if (!params) return template;
+  return template.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
+    const v = params[name];
+    return v === void 0 ? `{{${name}}}` : String(v);
+  });
+}
+var SUPPORTED, currentLocale, cache;
+var init_i18n = __esm({
+  "src/i18n/index.ts"() {
+    SUPPORTED = /* @__PURE__ */ new Set(["en", "zh-Hans"]);
+    currentLocale = null;
+    cache = {};
+  }
+});
+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 +1042,7 @@ function migrateLegacyHarnessedRoot() {
 }
 var init_harnessedRoot = __esm({
   "src/installers/lib/harnessedRoot.ts"() {
+    init_platform();
   }
 });
 function getBackupRoot() {
@@ -1895,8 +2048,20 @@ var init_loadPhases = __esm({
     };
   }
 });
-async function loadRolePrompts(workflowsDir) {
-  const path = join(workflowsDir, "role-prompts.yaml");
+function resolveLocaleYaml(dir, baseName, locale = getLocale()) {
+  if (locale !== "en") {
+    const sibling = join(dir, `${baseName}.${locale}.yaml`);
+    if (existsSync(sibling)) return sibling;
+  }
+  return join(dir, `${baseName}.yaml`);
+}
+var init_localeYaml = __esm({
+  "src/i18n/localeYaml.ts"() {
+    init_i18n();
+  }
+});
+async function loadRolePrompts(workflowsDir, locale = getLocale()) {
+  const path = resolveLocaleYaml(workflowsDir, "role-prompts", locale);
   let raw;
   try {
     raw = await readFile(path, "utf8");
@@ -2056,7 +2221,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) {
@@ -2075,7 +2240,7 @@ async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabiliti
     if (fileExists2(path)) {
       let existing = "";
       try {
-        existing = readFileSync12(path);
+        existing = readFileSync13(path);
       } catch {
         existing = "";
       }
@@ -2110,6 +2275,8 @@ async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabiliti
 var INTERACTIVE_COMMANDS, ORCHESTRATOR_COMMANDS, MARKER, LANG_DIRECTIVE, HARNESSED_MARKER_RX, V3_4_3_SIGNATURE_SUB_RX, V3_4_3_SIGNATURE_MASTER_RX;
 var init_generateCommands = __esm({
   "src/cli/lib/generateCommands.ts"() {
+    init_i18n();
+    init_localeYaml();
     INTERACTIVE_COMMANDS = /* @__PURE__ */ new Set([
       "discuss",
       "discuss-strategic",
@@ -4373,7 +4540,7 @@ var init_check_mattpocock_skills = __esm({
   }
 });
 function getUserClaudeJsonPath() {
-  return join(homedir(), ".claude.json");
+  return getMcpConfigPath();
 }
 async function readUserClaudeJson() {
   const path = getUserClaudeJsonPath();
@@ -4399,21 +4566,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);
@@ -4429,6 +4595,7 @@ async function isPluginRegistered(pluginName) {
 }
 var init_readClaudeConfig = __esm({
   "src/installers/lib/readClaudeConfig.ts"() {
+    init_platform();
   }
 });
 
@@ -4827,6 +4994,7 @@ var init_ccHookAdd2 = __esm({
     init_confirm();
     init_diff();
     init_err();
+    init_platform();
     init_preflight();
     init_state2();
     installCcHookAdd = async (ctx) => {
@@ -4850,10 +5018,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;
       }
@@ -4884,7 +5052,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});
@@ -4895,10 +5063,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,
@@ -4926,7 +5094,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] };
     };
   }
 });
@@ -4982,10 +5150,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: {
@@ -5001,7 +5169,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: {
@@ -5016,7 +5184,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 });
     });
   });
 }
@@ -5056,7 +5224,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;
@@ -5075,8 +5243,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;
@@ -5095,7 +5263,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;
@@ -5129,6 +5297,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;
@@ -5139,7 +5308,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 = "";
@@ -5148,15 +5317,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 });
     });
   });
 }
@@ -5326,7 +5495,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 = "";
@@ -5335,15 +5504,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 });
     });
   });
 }
@@ -6284,8 +6453,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" };
@@ -6784,73 +6959,9 @@ audited ${yamls.length} manifest${yamls.length === 1 ? "" : "s"} \u2014 ${findin
     process.exit(errorCount > 0 ? 1 : 0);
   });
 }
-var SUPPORTED = /* @__PURE__ */ new Set(["en", "zh-Hans"]);
-var currentLocale = null;
-var cache = {};
-function mapToSupported(raw) {
-  if (!raw) return "en";
-  if (/^zh([^a-z]|$)/i.test(raw)) return "zh-Hans";
-  return "en";
-}
-function detectLocale() {
-  const raw = process.env.HARNESSED_LANG || process.env.LC_ALL || process.env.LANG || process.env.LANGUAGE || safeIntlLocale();
-  return mapToSupported(raw);
-}
-function safeIntlLocale() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().locale;
-  } catch {
-    return void 0;
-  }
-}
-function messagesDir() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const candidates = [resolve(here, "..", "..", "messages"), resolve(here, "..", "messages")];
-  for (const c of candidates) {
-    try {
-      readFileSync(join(c, "en.json"), "utf8");
-      return c;
-    } catch {
-    }
-  }
-  return resolve(process.cwd(), "messages");
-}
-function loadLocale(locale) {
-  if (cache[locale]) return cache[locale];
-  const path = join(messagesDir(), `${locale}.json`);
-  try {
-    const raw = readFileSync(path, "utf8");
-    cache[locale] = JSON.parse(raw);
-  } catch {
-    cache[locale] = {};
-  }
-  return cache[locale];
-}
-function setLocale(locale) {
-  if (!locale) return;
-  const mapped = mapToSupported(locale);
-  if (SUPPORTED.has(mapped)) currentLocale = mapped;
-}
-function getLocale() {
-  if (currentLocale === null) currentLocale = detectLocale();
-  return currentLocale;
-}
-function t(key, params) {
-  const locale = getLocale();
-  const primary = loadLocale(locale);
-  let template = primary[key];
-  if (template === void 0 && locale !== "en") {
-    template = loadLocale("en")[key];
-  }
-  if (template === void 0) template = key;
-  if (!params) return template;
-  return template.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
-    const v = params[name];
-    return v === void 0 ? `{{${name}}}` : String(v);
-  });
-}
 
 // src/cli/audit-log.ts
+init_i18n();
 init_harnessedRoot();
 function auditPath() {
   return harnessedFile("audit.log");
@@ -6882,7 +6993,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
@@ -6891,12 +7002,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();
   });
@@ -6957,6 +7068,9 @@ function registerAuditLog(program2) {
     }
   );
 }
+
+// src/cli/backup-list.ts
+init_i18n();
 init_backup();
 function registerBackupList(program2) {
   const backup2 = program2.command("backup").description("Backup snapshot operations");
@@ -7192,6 +7306,7 @@ function registerCompact(program2) {
 }
 
 // src/cli/doctor.ts
+init_i18n();
 init_doctor_registry();
 function registerDoctor(program2) {
   program2.command("doctor").description(
@@ -7348,6 +7463,9 @@ function fireEntry(clause, master) {
   if (isMaster) entry.is_master = true;
   return entry;
 }
+
+// src/cli/gc.ts
+init_i18n();
 init_backup();
 var DURATION_RE = /^(\d+)([dhmw])$/;
 function parseDuration(s) {
@@ -7438,6 +7556,7 @@ ${t("gc.invalid_duration.fix")}`
 
 // src/cli/install.ts
 init_package();
+init_i18n();
 init_installers();
 init_path_guard();
 init_validate();
@@ -7458,24 +7577,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}`);
@@ -7535,74 +7656,248 @@ function registerLearn(program2) {
     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" },
-  { q: "\u2462 \u4E0E\u5DF2\u88C5\u914D\u7EC4\u4EF6\u6709 overlap surface \u5417?", f: "q3_overlap" },
-  { q: "\u2463 \u662F import \u6982\u5FF5 (\u53EF\u63A7) \u8FD8\u662F import \u522B\u4EBA\u4EA7\u54C1\u8EAB\u4EFD (\u9AD8\u8026\u5408)?", f: "q4_concept_vs_identity" },
-  { q: "\u2464 user \u4E0D\u77E5 upstream \u8FD8\u80FD\u7406\u89E3\u8BE5\u88C5\u914D\u5417?", f: "q5_user_understanding" }
-];
-function basename(upstream) {
-  return (upstream.split("/").pop() ?? upstream).replace(/\.git$/, "");
-}
-function registerManifestAdd(program2) {
-  program2.command("manifest-add <upstream>").description(
-    "Add a new upstream adapter (EE-5 5-question merge gate; immediate by default \u2014 use --dry-run for preview)"
-  ).option("--category <cat>", "manifest category (skill-packs | tools)", "skill-packs").option("--name <name>", "short adapter name (defaults to <upstream> basename)").option("--dry-run", "preview only \u2014 do not write JSON (opt-in for advanced users)").option("--non-interactive", "CI/scripts \u2014 WARN-only dry-run").action(async (upstream, raw) => {
-    const name = raw.name ?? basename(upstream);
-    const category = raw.category ?? "skill-packs";
-    const outPath = `manifests/${category}/${name}.ee5-answers.json`;
-    if (raw.nonInteractive) {
-      console.warn(t("manifest_add.non_interactive_warn"));
-      console.log(t("manifest_add.dry_run_preview", { upstream, path: outPath }));
-      process.exit(0);
-    }
-    const rl = readline.createInterface({ input: stdin, output: stdout });
-    const payload = {
-      upstream,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      author: process.env.USER ?? process.env.USERNAME ?? "unknown"
-    };
-    for (const { q, f } of QA) {
-      const a = (await rl.question(`${q}
-> `)).trim();
-      if (!a) {
-        console.error(t("manifest_add.empty_answer"));
-        rl.close();
-        process.exit(1);
-      }
-      payload[f] = a;
-    }
-    rl.close();
-    const dryRun = raw.dryRun === true;
-    if (!dryRun) {
-      writeFileSync(outPath, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-      console.log(t("manifest_add.gate_passed_wrote", { path: outPath }));
-    } else {
-      console.log(t("manifest_add.gate_passed_dry_run", { path: outPath }));
-      console.log(JSON.stringify(payload, null, 2));
-    }
-    process.exit(0);
-  });
-}
 
-// 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 current = await readCurrentWorkflow2();
-    const ledger = current?.sub_progress ?? [];
-    const auto = resolveAutoTransition(current?.auto_transition);
+// src/cli/lib/here.ts
+init_nextStep();
+init_i18n();
+init_harnessedRoot();
+
+// src/cli/status.ts
+init_evidence();
+init_ledger();
+init_state();
+init_i18n();
+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);
+}
+
+// src/cli/manifest-add.ts
+init_i18n();
+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" },
+  { q: "\u2462 \u4E0E\u5DF2\u88C5\u914D\u7EC4\u4EF6\u6709 overlap surface \u5417?", f: "q3_overlap" },
+  { q: "\u2463 \u662F import \u6982\u5FF5 (\u53EF\u63A7) \u8FD8\u662F import \u522B\u4EBA\u4EA7\u54C1\u8EAB\u4EFD (\u9AD8\u8026\u5408)?", f: "q4_concept_vs_identity" },
+  { q: "\u2464 user \u4E0D\u77E5 upstream \u8FD8\u80FD\u7406\u89E3\u8BE5\u88C5\u914D\u5417?", f: "q5_user_understanding" }
+];
+function basename(upstream) {
+  return (upstream.split("/").pop() ?? upstream).replace(/\.git$/, "");
+}
+function registerManifestAdd(program2) {
+  program2.command("manifest-add <upstream>").description(
+    "Add a new upstream adapter (EE-5 5-question merge gate; immediate by default \u2014 use --dry-run for preview)"
+  ).option("--category <cat>", "manifest category (skill-packs | tools)", "skill-packs").option("--name <name>", "short adapter name (defaults to <upstream> basename)").option("--dry-run", "preview only \u2014 do not write JSON (opt-in for advanced users)").option("--non-interactive", "CI/scripts \u2014 WARN-only dry-run").action(async (upstream, raw) => {
+    const name = raw.name ?? basename(upstream);
+    const category = raw.category ?? "skill-packs";
+    const outPath = `manifests/${category}/${name}.ee5-answers.json`;
+    if (raw.nonInteractive) {
+      console.warn(t("manifest_add.non_interactive_warn"));
+      console.log(t("manifest_add.dry_run_preview", { upstream, path: outPath }));
+      process.exit(0);
+    }
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const payload = {
+      upstream,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      author: process.env.USER ?? process.env.USERNAME ?? "unknown"
+    };
+    for (const { q, f } of QA) {
+      const a = (await rl.question(`${q}
+> `)).trim();
+      if (!a) {
+        console.error(t("manifest_add.empty_answer"));
+        rl.close();
+        process.exit(1);
+      }
+      payload[f] = a;
+    }
+    rl.close();
+    const dryRun = raw.dryRun === true;
+    if (!dryRun) {
+      writeFileSync(outPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+      console.log(t("manifest_add.gate_passed_wrote", { path: outPath }));
+    } else {
+      console.log(t("manifest_add.gate_passed_dry_run", { path: outPath }));
+      console.log(JSON.stringify(payload, null, 2));
+    }
+    process.exit(0);
+  });
+}
+
+// src/cli/next.ts
+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, resolveAutoTransition: resolveAutoTransition2 } = await Promise.resolve().then(() => (init_nextStep(), nextStep_exports));
+    const current = await readCurrentWorkflow2();
+    const ledger = current?.sub_progress ?? [];
+    const auto = resolveAutoTransition2(current?.auto_transition);
     const step = resolveNext2(ledger, auto);
     console.log(`NEXT: ${step.next}`);
     if (step.sub) console.log(`SUB: ${step.sub}`);
@@ -7612,6 +7907,8 @@ function registerNext(program2) {
 }
 
 // src/cli/prompt.ts
+init_i18n();
+init_localeYaml();
 init_run();
 init_generateCommands();
 init_packagePath();
@@ -7657,16 +7954,17 @@ ${lines.join("\n")}
     return "";
   }
 }
-async function buildDisciplinesSection(sub, packageRoot) {
+async function buildDisciplinesSection(sub, packageRoot, locale = getLocale()) {
   try {
     const workflowsDir = resolve(packageRoot, "workflows");
+    const disciplinesDir = resolve(workflowsDir, "disciplines");
     const applied = await loadSubArrayField(sub, packageRoot, "disciplines_applied");
     const names = applied.filter((d) => d !== "language");
     if (names.length === 0) return "";
     const blocks = [];
     for (const name of names) {
       try {
-        const dRaw = await readFile(resolve(workflowsDir, "disciplines", `${name}.yaml`), "utf8");
+        const dRaw = await readFile(resolveLocaleYaml(disciplinesDir, name, locale), "utf8");
         const dDoc = parse(dRaw);
         const rules = Array.isArray(dDoc?.rules) ? dDoc.rules : [];
         const descs = rules.map((r) => typeof r.description === "string" ? r.description.trim() : "").filter((s) => s.length > 0).map((s) => `  - ${s.replace(/\s+/g, " ")}`);
@@ -7812,6 +8110,9 @@ function registerReleasePreflight(program2) {
     process.exit(failed ? 1 : 0);
   });
 }
+
+// src/cli/research.ts
+init_i18n();
 init_run();
 init_packagePath();
 init_run2();
@@ -7853,6 +8154,7 @@ function registerResearch(program2) {
 }
 
 // src/cli/resume.ts
+init_i18n();
 function registerResume(program2) {
   program2.command("resume").description(
     "Reload checkpoint from paused workflow + print resume hint (D-03 \u2014 user invokes phase command manually)"
@@ -7917,6 +8219,9 @@ function registerRetro(program2) {
     process.exit(0);
   });
 }
+
+// src/cli/rollback.ts
+init_i18n();
 init_backup();
 function normalizeEol(buf, eol) {
   const lf = buf.toString("utf8").replace(/\r\n/g, "\n");
@@ -7988,9 +8293,16 @@ ${t("rollback.metadata_unreadable.fix")}`
 
 // src/cli.ts
 init_run2();
+
+// src/cli/setup.ts
+init_i18n();
+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");
@@ -8015,8 +8327,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();
@@ -8093,55 +8404,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");
@@ -8166,11 +8479,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";
@@ -8188,115 +8524,104 @@ 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 };
   }
 }
 
 // src/cli/setup.ts
 init_generateCommands();
 init_packagePath();
+
+// src/cli/lib/renderSkillTemplates.ts
+init_i18n();
+
+// src/cli/lib/resolveSkillBody.ts
+init_i18n();
+function skillBodyFilename(locale) {
+  return locale === "en" ? "SKILL.md" : `SKILL.${locale}.md`;
+}
+function resolveSkillBodyFilename(skillDir, locale) {
+  const resolved = locale ?? getLocale();
+  const candidate = skillBodyFilename(resolved);
+  if (candidate === "SKILL.md") return "SKILL.md";
+  return existsSync(join(skillDir, candidate)) ? candidate : "SKILL.md";
+}
+
+// src/cli/lib/renderSkillTemplates.ts
+var LOCALE_SIBLINGS = ["zh-Hans"];
 async function loadCapabilities(workflowsDir) {
   const path = join(workflowsDir, "capabilities.yaml");
   const raw = await readFile(path, "utf8");
   const doc = parse(raw);
   return doc?.capabilities ?? {};
 }
-async function renderSkillFile(skillName, skillsBase, capabilities, installedPlugins, installedUserSkills) {
-  const skillPath = join(skillsBase, skillName, "SKILL.md");
+async function renderSkillFile(skillName, skillsBase, capabilities, installedPlugins, installedUserSkills, locale) {
+  const dir = join(skillsBase, skillName);
+  const resolved = locale ?? getLocale();
+  const srcName = resolveSkillBodyFilename(dir, resolved);
+  const srcPath = join(dir, srcName);
+  const destPath = join(dir, "SKILL.md");
   const result = {
     name: skillName,
-    skillPath,
+    skillPath: destPath,
     rendered: false,
     warnings: []
   };
   let body;
   try {
-    body = await readFile(skillPath, "utf8");
+    body = await readFile(srcPath, "utf8");
   } catch (e) {
     result.error = `read failed: ${e.message}`;
     return result;
   }
   const rendered = renderSkillBody(body, capabilities, installedPlugins, installedUserSkills);
-  if (rendered.body === body) {
+  const localeBodySelected = srcName !== "SKILL.md";
+  const needsWrite = localeBodySelected || rendered.body !== body;
+  if (!needsWrite) {
     result.warnings = rendered.warnings;
     return result;
   }
   try {
-    await writeFile(skillPath, rendered.body, "utf8");
-    result.rendered = true;
+    await writeFile(destPath, rendered.body, "utf8");
+    result.rendered = rendered.body !== body;
     result.warnings = rendered.warnings;
   } catch (e) {
     result.error = `write failed: ${e.message}`;
+    return result;
+  }
+  if (localeBodySelected) {
+    for (const loc of LOCALE_SIBLINGS) {
+      const sibling = skillBodyFilename(loc);
+      if (sibling === "SKILL.md") continue;
+      try {
+        await rm(join(dir, sibling), { force: true });
+      } catch {
+      }
+    }
   }
   return result;
 }
-async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOverride) {
+async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOverride, locale) {
+  const resolvedLocale = locale ?? getLocale();
   let capabilities = {};
   try {
     capabilities = await loadCapabilities(workflowsDir);
@@ -8314,8 +8639,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) {
@@ -8324,7 +8649,8 @@ async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOver
       skillsBase,
       capabilities,
       installedPlugins,
-      installedUserSkills
+      installedUserSkills,
+      resolvedLocale
     );
     results.push(r);
     for (const w of r.warnings) warningSet.add(w);
@@ -8478,6 +8804,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"]) {
@@ -8530,14 +8873,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 {
@@ -8574,14 +8918,20 @@ function registerSetup(program2) {
     }
     console.log(t("setup.step_a_complete", { count: skillsInstalled, path: skillsBase }));
     const skillNames = toInstall.map((wf) => wf.name);
-    const rendered = await renderAllSkills(skillNames, skillsBase, workflowsDir);
+    const rendered = await renderAllSkills(
+      skillNames,
+      skillsBase,
+      workflowsDir,
+      void 0,
+      getLocale()
+    );
     if (rendered.aggregatedWarnings.length > 0) {
       console.warn(t("setup.step_a_render.warnings_header"));
       for (const w of rendered.aggregatedWarnings) {
         console.warn(`    - ${w}`);
       }
     }
-    const commandsBase = resolve(homedir(), ".claude", "commands");
+    const commandsBase = getCommandsDir();
     try {
       await mkdir(commandsBase, { recursive: true });
     } catch (e) {
@@ -8677,115 +9027,8 @@ Force-update pass complete: ${b2.installed.length} installed / ${b2.alreadyInsta
   });
 }
 
-// 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/uninstall.ts
+init_i18n();
 init_harnessedRoot();
 init_path_guard();
 init_validate();
@@ -8804,10 +9047,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: [] };
   }
@@ -8836,8 +9079,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
@@ -8976,7 +9219,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) => {
@@ -8984,15 +9227,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) {
@@ -9058,9 +9301,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 {
@@ -9071,8 +9314,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;
@@ -9087,14 +9330,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 = [];
@@ -9105,7 +9348,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) {
@@ -9163,9 +9406,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);
@@ -9362,6 +9605,7 @@ function registerWorkflows(program2) {
 }
 
 // src/cli.ts
+init_i18n();
 init_harnessedRoot();
 migrateLegacyHarnessedRoot();
 var argv = process.argv;
@@ -9413,6 +9657,11 @@ registerLearn(program);
 registerUpdate(program);
 registerReleasePreflight(program);
 registerRetro(program);
-program.parse(process.argv);
+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