harnessed 3.3.1 → 3.4.1

package/dist/cli.mjs

@@ -11,12 +11,12 @@ import lockfile from 'proper-lockfile';
 import { Command } from 'commander';
 import { Ajv } from 'ajv';
 import * as ajvFormatsNs from 'ajv-formats';
+import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import * as p from '@clack/prompts';
 import { createPatch } from 'diff';
 import pc from 'picocolors';
-import { fileURLToPath } from 'url';
 import { stdout, stdin } from 'process';
 import * as readline from 'readline/promises';
 
@@ -498,7 +498,7 @@ function checkTokenBudget() {
     const msg = `${items.length} skill(s) total ${total} tokens (under 1% / 2000 threshold)`;
     return { name: "token budget", status: "pass", message: msg };
   }
-  const top = [...items].sort((a, b) => b.tokens - a.tokens).slice(0, 3).map((t) => `${t.name}:${t.tokens}`).join(", ");
+  const top = [...items].sort((a, b) => b.tokens - a.tokens).slice(0, 3).map((t2) => `${t2.name}:${t2.tokens}`).join(", ");
   const pct = (total / CONTEXT_WINDOW_TOKENS * 100).toFixed(2);
   const message = `${items.length} skill(s) total ${total} tokens (${pct}% of 200000) \u2014 top: ${top}`;
   return {
@@ -847,7 +847,7 @@ var init_resume = __esm({
 
 // package.json
 var package_default = {
-  version: "3.3.1"};
+  version: "3.4.1"};
 
 // src/manifest/errors.ts
 function instancePathToKeyPath(instancePath) {
@@ -1600,6 +1600,71 @@ 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_harnessedRoot();
@@ -1633,7 +1698,7 @@ function renderHumanTable(records) {
   }
 }
 function pipeToJq(filterExpr, lines) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve12, reject) => {
     const child = spawn("jq", [filterExpr], {
       stdio: ["pipe", "inherit", "inherit"],
       windowsHide: true
@@ -1641,13 +1706,13 @@ function pipeToJq(filterExpr, lines) {
     child.on("error", (err2) => {
       const e = err2;
       if (e.code === "ENOENT") {
-        console.error("\u2717 jq not found in PATH \u2014 run: harnessed doctor");
-        resolve10(1);
+        console.error(t("audit_log.jq_missing"));
+        resolve12(1);
       } else {
         reject(err2);
       }
     });
-    child.on("close", (code) => resolve10(code ?? 0));
+    child.on("close", (code) => resolve12(code ?? 0));
     child.stdin.write(lines.join("\n"));
     child.stdin.end();
   });
@@ -1659,23 +1724,23 @@ function registerAuditLog(program2) {
     async (opts) => {
       const tailN = opts.tail !== void 0 ? Number(opts.tail) : 50;
       if (Number.isNaN(tailN) || tailN < 1) {
-        console.error("\u2717 --tail must be a positive integer");
+        console.error(t("audit_log.tail_invalid"));
         process.exit(2);
       }
       const headN = opts.head !== void 0 ? Number(opts.head) : void 0;
       if (headN !== void 0 && (Number.isNaN(headN) || headN < 1)) {
-        console.error("\u2717 --head must be a positive integer");
+        console.error(t("audit_log.head_invalid"));
         process.exit(2);
       }
       const path = auditPath();
       if (!existsSync(path)) {
-        console.log(`no audit records found (${path} does not exist)`);
+        console.log(t("audit_log.no_records_file", { path }));
         process.exit(0);
       }
       const raw = readFileSync(path, "utf8");
       const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
       if (lines.length === 0) {
-        console.log("no audit records found (audit.log is empty)");
+        console.log(t("audit_log.no_records_empty"));
         process.exit(0);
       }
       let records = [];
@@ -1832,11 +1897,11 @@ function registerBackupList(program2) {
     try {
       dirs = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
     } catch {
-      console.log(`no backups found (${root} absent)`);
+      console.log(t("backup.no_backups", { root }));
       return;
     }
     if (dirs.length === 0) {
-      console.log(`no backups found (${root} empty)`);
+      console.log(t("backup.no_backups_empty", { root }));
       return;
     }
     for (const ts of dirs) {
@@ -1851,8 +1916,7 @@ function registerBackupList(program2) {
         console.log(`${ts}  (metadata.json missing or unreadable)`);
       }
     }
-    console.log(`
-${dirs.length} snapshot${dirs.length === 1 ? "" : "s"} total`);
+    console.log(t("backup.total_snapshots", { count: dirs.length }));
   });
 }
 function checkNodeVersion() {
@@ -1998,7 +2062,7 @@ function registerDoctor(program2) {
         if (r.status !== "pass" && r.fix) console.log(`    fix: ${r.fix}`);
       }
       console.log(
-        hasFail ? "\nsome checks failed (see fix hints above)" : hasWarn ? "\nall checks ok (with warnings \u2014 see hints above)" : "\nall checks passed"
+        hasFail ? t("doctor.summary.fail") : hasWarn ? t("doctor.summary.warn") : t("doctor.summary.pass")
       );
     }
     process.exit(hasFail ? 1 : 0);
@@ -3005,7 +3069,7 @@ function registerExecuteTask(program2) {
     "Run execute-task workflow (4-phase chain \u2192 ralph-loop COMPLETE; immediate by default \u2014 use --dry-run for preview)"
   ).requiredOption("--task <text>", "task description (required)").option("--workflow <name>", "workflow name", "execute-task").option("--dry-run", "preview only \u2014 do not spawn subagent (opt-in for advanced users)").option("--non-interactive", "CI / scripts").option("--model <model>", "subagent model: 'haiku' | 'sonnet' | 'opus'").option("--model-tier <tier>", "override: 'inherit' bypasses per-phase phase.model (B-10)").option("--max-iterations <n>", "ralph-loop max iter (default 20)", (v) => parseInt(v, 10)).action(async (raw) => {
     if (!raw.task) {
-      console.error("error: --task <text> is required");
+      console.error(t("execute_task.require_task"));
       process.exit(2);
     }
     const workflowName = raw.workflow ?? "execute-task";
@@ -3014,7 +3078,10 @@ function registerExecuteTask(program2) {
       phases = loadPhases(`workflows/${workflowName}/phases.yaml`);
     } catch (error) {
       console.error(
-        `error: failed to load workflows/${workflowName}/phases.yaml \u2014 ${error.message}`
+        t("execute_task.load_phases_failed", {
+          workflow: workflowName,
+          message: error.message
+        })
       );
       process.exit(2);
     }
@@ -3053,9 +3120,7 @@ function registerExecuteTask(program2) {
         // apply-immediate default
       });
     } catch (err2) {
-      console.warn(
-        `\u26A0\uFE0F before-commit pre-flight skipped (${err2.message}); subagent will biome-check at commit time.`
-      );
+      console.warn(t("execute_task.precommit_skipped", { message: err2.message }));
     }
     const result = await runRouting(taskCtx, {
       maxIterations: raw.maxIterations ?? 20,
@@ -3064,7 +3129,7 @@ function registerExecuteTask(program2) {
       ...fallbackPhaseId ? { fallbackPhaseId } : {}
     });
     if ("aborted" in result) {
-      console.error(`aborted: ${result.reason}`);
+      console.error(t("install.aborted", { reason: result.reason }));
       process.exit(2);
     }
     if ("ok" in result && result.ok === false) {
@@ -3110,8 +3175,8 @@ function registerGc(program2) {
     const olderMs = parseDuration(opts.olderThan ?? "30d");
     if (olderMs == null) {
       console.error(
-        `error: invalid --older-than '${opts.olderThan}'
-  fix:  use format <N>{d|h|m|w} e.g. 30d / 24h / 60m / 4w`
+        `${t("gc.invalid_duration", { value: opts.olderThan ?? "" })}
+${t("gc.invalid_duration.fix")}`
       );
       process.exit(1);
       return;
@@ -3122,7 +3187,7 @@ function registerGc(program2) {
     try {
       dirs = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
     } catch {
-      console.log(`no backups found (${root} absent) \u2014 nothing to gc`);
+      console.log(t("gc.no_backups", { root }));
       return;
     }
     const cutoff = Date.now() - olderMs;
@@ -3132,8 +3197,8 @@ function registerGc(program2) {
       if (kept.has(ts)) continue;
       const path = join(root, ts);
       const iso = ts.replace(/T(\d{2})-(\d{2})-(\d{2})/, "T$1:$2:$3");
-      const t = Date.parse(iso);
-      if (Number.isNaN(t) || t > cutoff) continue;
+      const t2 = Date.parse(iso);
+      if (Number.isNaN(t2) || t2 > cutoff) continue;
       let manifest = "(unknown)";
       try {
         const meta = JSON.parse(
@@ -3146,17 +3211,19 @@ function registerGc(program2) {
       candidates.push({ ts, path, manifest, sizeKb });
     }
     if (candidates.length === 0) {
-      console.log(`no snapshots older than ${opts.olderThan} (kept ${kept.size} most-recent)`);
+      console.log(
+        t("gc.no_old_snapshots", { cutoff: opts.olderThan ?? "", keptCount: kept.size })
+      );
       return;
     }
     const totalKb = candidates.reduce((a, c) => a + c.sizeKb, 0);
-    const verb = dryRun ? "would delete" : "deleting";
-    console.log(`${verb} ${candidates.length} snapshot(s), ~${totalKb} KB total:`);
+    const key = dryRun ? "gc.summary_will_delete" : "gc.summary_deleting";
+    console.log(t(key, { count: candidates.length, sizeKb: totalKb }));
     for (const c of candidates) {
       console.log(`  ${c.ts}  ${c.manifest}  (${c.sizeKb} KB)`);
       if (!dryRun) await rm(c.path, { recursive: true, force: true });
     }
-    if (dryRun) console.log("\n(dry-run \u2014 re-run without --dry-run to actually delete)");
+    if (dryRun) console.log(t("gc.dry_run_rerun_hint"));
   });
 }
 async function confirmAt(level, ctx) {
@@ -3364,10 +3431,10 @@ var installCcHookAdd = async (ctx) => {
     const e = pre.errors[0] ?? err(ctx, "/", "preflight failed", "preflight");
     return { ok: false, phase: "preflight", error: e };
   }
-  const settingsPath2 = join(homedir(), ".claude", "settings.json");
+  const settingsPath3 = join(homedir(), ".claude", "settings.json");
   let existing;
   try {
-    existing = await readFile(settingsPath2, "utf8");
+    existing = await readFile(settingsPath3, "utf8");
   } catch {
     existing = null;
   }
@@ -3398,7 +3465,7 @@ var installCcHookAdd = async (ctx) => {
   const newText = `${JSON.stringify(settings, null, 2)}
 `;
   const plan = {
-    files: [{ target: settingsPath2, scope: "HOME", oldText: existing ?? "", newText }]
+    files: [{ target: settingsPath3, scope: "HOME", oldText: existing ?? "", newText }]
   };
   process.stdout.write(renderDiff(plan, ctx));
   const conf = await confirmAt("L3", { ...ctx});
@@ -3409,10 +3476,10 @@ var installCcHookAdd = async (ctx) => {
   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(settingsPath2, newText);
+  await writeFile(settingsPath3, newText);
   let verify;
   try {
-    verify = JSON.parse(await readFile(settingsPath2, "utf8"));
+    verify = JSON.parse(await readFile(settingsPath3, "utf8"));
   } catch (e) {
     return {
       ok: false,
@@ -3440,7 +3507,7 @@ var installCcHookAdd = async (ctx) => {
     };
   }
   await updateInstalled(ctx.cwd, ctx.manifest.metadata.name, "", "");
-  return { ok: true, backupId: bk.backupId, appliedFiles: [settingsPath2] };
+  return { ok: true, backupId: bk.backupId, appliedFiles: [settingsPath3] };
 };
 function getUserClaudeJsonPath() {
   return join(homedir(), ".claude.json");
@@ -3476,7 +3543,7 @@ async function isPluginRegistered(pluginName) {
   return Object.keys(plugins).some((k) => k.split("@")[0] === pluginName);
 }
 function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     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 = "";
@@ -3485,15 +3552,15 @@ function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve10({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
+      resolve12({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
     }, timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve10({ exitCode: -1, stderr: `${stderr}${e.message}` });
+      resolve12({ exitCode: -1, stderr: `${stderr}${e.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve10({ exitCode: code ?? -1, stderr });
+      resolve12({ exitCode: code ?? -1, stderr });
     });
   });
 }
@@ -3672,10 +3739,10 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
   child.stderr?.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  return await new Promise((resolve10) => {
+  return await new Promise((resolve12) => {
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve10({
+      resolve12({
         ok: false,
         phase: "spawn",
         error: {
@@ -3690,7 +3757,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     }, effectiveTimeoutMs);
     child.on("error", (err2) => {
       clearTimeout(timer);
-      resolve10({
+      resolve12({
         ok: false,
         phase: "spawn",
         error: {
@@ -3705,14 +3772,14 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve10({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
+      resolve12({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
     });
   });
 }
 
 // src/installers/gitCloneWithSetup.ts
 function gitRevParseHead(cwd, timeoutMs = 1e4) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     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 = "";
@@ -3721,15 +3788,15 @@ function gitRevParseHead(cwd, timeoutMs = 1e4) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve10({ sha: "", exit: -1 });
+      resolve12({ sha: "", exit: -1 });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve10({ sha: "", exit: -1 });
+      resolve12({ sha: "", exit: -1 });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve10({ sha: stdout2.trim(), exit: code ?? -1 });
+      resolve12({ sha: stdout2.trim(), exit: code ?? -1 });
     });
   });
 }
@@ -3740,11 +3807,11 @@ function extractCloneTarget(cmd) {
   const tokens = tail.split(/\s+/);
   let i = 0;
   while (i < tokens.length) {
-    const t = tokens[i];
-    if (t === void 0 || !t.startsWith("-")) break;
-    if (t === "--depth" || t === "--branch" || t === "-b") {
+    const t2 = tokens[i];
+    if (t2 === void 0 || !t2.startsWith("-")) break;
+    if (t2 === "--depth" || t2 === "--branch" || t2 === "-b") {
       i += 2;
-    } else if (t.includes("=")) {
+    } else if (t2.includes("=")) {
       i += 1;
     } else {
       i += 2;
@@ -4479,8 +4546,8 @@ function registerInstall(program2) {
         chosenPath = skillPackPath;
       } catch {
         console.error(
-          `error: manifest '${resolvedName}' not found
-  fix:  ensure manifests/tools/${resolvedName}.yaml or manifests/skill-packs/${resolvedName}.yaml exists`
+          `${t("install.manifest_not_found", { name: resolvedName })}
+${t("install.manifest_not_found.fix", { name: resolvedName })}`
         );
         process.exit(1);
       }
@@ -4488,7 +4555,7 @@ function registerInstall(program2) {
     const v = validateManifestFile(yamlSrc, chosenPath);
     if (!v.ok) {
       for (const e of v.errors) console.error(`error: ${e.message} at ${e.path}`);
-      console.error(`  fix:  run 'harnessed audit' to inspect manifest issues`);
+      console.error(t("install.audit_hint"));
       process.exit(1);
     }
     const dryRun = raw.dryRun === true;
@@ -4510,12 +4577,14 @@ function registerInstall(program2) {
     }
     const result = await runInstall(v.manifest, opts);
     if ("aborted" in result) {
-      console.error(`aborted: ${result.reason}`);
+      console.error(t("install.aborted", { reason: result.reason }));
       process.exit(2);
     }
     if (result.ok) {
       const version = v.manifest.spec.install.method === "npm-cli" && "npm_version" in v.manifest.spec.install ? v.manifest.spec.install.npm_version : "";
-      console.log(`installed ${v.manifest.metadata.name}${version ? `@${version}` : ""}`);
+      console.log(
+        version ? t("install.success_with_version", { name: v.manifest.metadata.name, version }) : t("install.success", { name: v.manifest.metadata.name })
+      );
       process.exit(0);
     }
     console.error(formatError(result.error));
@@ -4613,10 +4682,8 @@ function registerManifestAdd(program2) {
     const category = raw.category ?? "skill-packs";
     const outPath = `manifests/${category}/${name}.ee5-answers.json`;
     if (raw.nonInteractive) {
-      console.warn(
-        "[ee-5-gate] WARN: --non-interactive skips 5-question prompt (D-03 dry-run-only). plan-phase hard reject still applies."
-      );
-      console.log(`[manifest-add] dry-run preview for upstream: ${upstream} \u2192 ${outPath}`);
+      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 });
@@ -4629,7 +4696,7 @@ function registerManifestAdd(program2) {
       const a = (await rl.question(`${q}
 > `)).trim();
       if (!a) {
-        console.error("error: EE-5 gate requires non-empty answer");
+        console.error(t("manifest_add.empty_answer"));
         rl.close();
         process.exit(1);
       }
@@ -4640,9 +4707,9 @@ function registerManifestAdd(program2) {
     if (!dryRun) {
       writeFileSync(outPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
-      console.log(`[manifest-add] EE-5 gate passed; wrote ${outPath}`);
+      console.log(t("manifest_add.gate_passed_wrote", { path: outPath }));
     } else {
-      console.log(`[manifest-add] EE-5 gate passed (dry-run); would write ${outPath}`);
+      console.log(t("manifest_add.gate_passed_dry_run", { path: outPath }));
       console.log(JSON.stringify(payload, null, 2));
     }
     process.exit(0);
@@ -4655,7 +4722,7 @@ function registerResearch(program2) {
     "Run research workflow (search category sub-routing \u2192 spawn \u2192 verbatim COMPLETE; immediate by default \u2014 use --dry-run for preview)"
   ).requiredOption("--query <text>", "research prompt (required)").option("--dry-run", "preview only \u2014 do not spawn subagent (opt-in for advanced users)").option("--non-interactive", "skip all prompts (CI / scripts)").option("--model <model>", "subagent model: 'haiku' | 'sonnet' | 'opus'").action(async (raw) => {
     if (!raw.query) {
-      console.error("error: --query <text> is required");
+      console.error(t("research.require_query"));
       process.exit(2);
     }
     const taskCtx = { task: raw.query, task_type: "search" };
@@ -4668,31 +4735,33 @@ function registerResearch(program2) {
         ...raw.model ? { agentOpts: { modelOverride: raw.model } } : {}
       });
       if ("aborted" in preview) {
-        console.error(`aborted: ${preview.reason}`);
+        console.error(t("install.aborted", { reason: preview.reason }));
         process.exit(2);
       }
       if ("ok" in preview && preview.ok === false) {
         console.error(`error: ${preview.phase} \u2014 ${preview.error.message}`);
         process.exit(1);
       }
-      console.log(`[dry-run] matched_rule: ${preview.matchedRule?.id ?? "(fallback supervisor)"}`);
-      console.log(`[dry-run] query: ${raw.query}`);
       console.log(
-        "  (run without --dry-run to spawn the subagent and emit verbatim COMPLETE round-trip)"
+        t("research.dry_run.matched_rule", {
+          rule: preview.matchedRule?.id ?? "(fallback supervisor)"
+        })
       );
+      console.log(t("research.dry_run.query", { query: raw.query }));
+      console.log(t("research.dry_run.run_hint"));
       process.exit(0);
     }
     const result = await runRouting(taskCtx, {
       ...raw.model ? { agentOpts: { modelOverride: raw.model } } : {}
     });
     if ("aborted" in result) {
-      console.error(`aborted: ${result.reason}`);
+      console.error(t("install.aborted", { reason: result.reason }));
       process.exit(2);
     }
     if ("ok" in result && result.ok === false) {
       console.error(`error: ${result.phase} \u2014 ${result.error.message}`);
       if (result.phase === "install") {
-        console.error(`  fix:  'harnessed install <skill>' (see error above)`);
+        console.error(t("research.install_fix_hint"));
       }
       process.exit(1);
     }
@@ -4714,12 +4783,11 @@ function registerResume(program2) {
       return;
     }
     if (r.status === "no-paused-phase") {
-      console.error(`\u2717 ${r.error}`);
+      console.error(t("resume.fail", { error: r.error }));
       process.exit(1);
     }
     if (r.status === "corrupt") {
-      console.error(`\u2717 ${r.error}
-    path: ${r.path}`);
+      console.error(t("resume.corrupt", { error: r.error, path: r.path }));
       process.exit(1);
     }
     if (r.cwdWarn) console.error(r.cwdWarn);
@@ -4748,8 +4816,8 @@ function registerRollback(program2) {
       meta = JSON.parse(await readFile(metaPath, "utf8"));
     } catch (err2) {
       console.error(
-        `error: cannot read ${metaPath}: ${err2.message}
-  fix:  run 'harnessed backup list' to see available timestamps`
+        `${t("rollback.metadata_unreadable", { path: metaPath, message: err2.message })}
+${t("rollback.metadata_unreadable.fix")}`
       );
       process.exit(1);
       return;
@@ -4772,14 +4840,18 @@ function registerRollback(program2) {
       const sha1 = createHash("sha1").update(buf).digest("hex");
       if (sha1 !== entry.sha1) {
         console.error(
-          `error: backup checksum mismatch for ${entry.target} (expected ${entry.sha1.slice(0, 12)}, got ${sha1.slice(0, 12)})`
+          t("rollback.checksum_mismatch", {
+            target: entry.target,
+            expected: entry.sha1.slice(0, 12),
+            actual: sha1.slice(0, 12)
+          })
         );
         process.exit(1);
         return;
       }
       await writeFile(entry.target, normalizeEol(buf, entry.eol));
     }
-    console.log(`restored ${meta.files.length} file(s) from ${timestamp}`);
+    console.log(t("rollback.restored", { count: meta.files.length, timestamp }));
   });
 }
 
@@ -4856,6 +4928,221 @@ async function atomicWrite(path, content) {
     return `write ${path} failed: ${err2.message}`;
   }
 }
+
+// src/cli/lib/enableUserLangInSettings.ts
+init_harnessedRoot();
+function settingsPath2() {
+  return resolve(homedir(), ".claude", "settings.json");
+}
+function detectUserLang(override) {
+  if (override) {
+    if (/^zh([^a-z]|$)/i.test(override)) return "zh-Hans";
+    return "en";
+  }
+  const raw = process.env.HARNESSED_LANG || process.env.LC_ALL || process.env.LANG || process.env.LANGUAGE || safeIntlLocale2() || "";
+  if (/^zh([^a-z]|$)/i.test(raw)) return "zh-Hans";
+  return "en";
+}
+function safeIntlLocale2() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale;
+  } catch {
+    return void 0;
+  }
+}
+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}` };
+  }
+}
+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}`;
+  }
+}
+function readInstalledPlugins(homedirOverride) {
+  const home = homedir();
+  const path = join(home, ".claude", "plugins", "installed_plugins.json");
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  if (!parsed || typeof parsed !== "object") return /* @__PURE__ */ new Set();
+  const plugins = parsed.plugins;
+  if (!plugins || typeof plugins !== "object") return /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(plugins)) {
+    const at = key.indexOf("@");
+    if (at <= 0) continue;
+    out.add(key.slice(0, at));
+  }
+  return out;
+}
+function resolveCapabilityCmd(capability, installedPlugins) {
+  const { cmd, plugin_namespace } = capability;
+  if (!plugin_namespace) return { renderedCmd: cmd };
+  if (cmd.includes(":")) return { renderedCmd: cmd };
+  if (!cmd.startsWith("/")) return { renderedCmd: cmd };
+  if (!installedPlugins.has(plugin_namespace)) {
+    return {
+      renderedCmd: cmd,
+      warning: `plugin '${plugin_namespace}' not installed \u2014 '${cmd}' will not resolve via Claude Code. install: 'claude plugin install ${plugin_namespace}' or see plugin docs.`
+    };
+  }
+  const bare = cmd.slice(1);
+  return { renderedCmd: `/${plugin_namespace}:${bare}` };
+}
+var CAPABILITY_CMD_TEMPLATE = /\{\{\s*capabilities\.([a-zA-Z0-9_-]+)\.cmd\s*\}\}/g;
+function renderSkillBody(body, capabilities, installedPlugins) {
+  const warningsSet = /* @__PURE__ */ new Set();
+  const out = body.replace(CAPABILITY_CMD_TEMPLATE, (match2, name) => {
+    const cap = capabilities[name];
+    if (!cap) {
+      warningsSet.add(
+        `capability '${name}' referenced in SKILL.md but not defined in capabilities.yaml`
+      );
+      return match2;
+    }
+    const { renderedCmd, warning } = resolveCapabilityCmd(cap, installedPlugins);
+    if (warning) warningsSet.add(warning);
+    return renderedCmd;
+  });
+  return { body: out, warnings: [...warningsSet] };
+}
+
+// src/cli/lib/renderSkillTemplates.ts
+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) {
+  const skillPath = join(skillsBase, skillName, "SKILL.md");
+  const result = {
+    name: skillName,
+    skillPath,
+    rendered: false,
+    warnings: []
+  };
+  let body;
+  try {
+    body = await readFile(skillPath, "utf8");
+  } catch (e) {
+    result.error = `read failed: ${e.message}`;
+    return result;
+  }
+  const rendered = renderSkillBody(body, capabilities, installedPlugins);
+  if (rendered.body === body) {
+    result.warnings = rendered.warnings;
+    return result;
+  }
+  try {
+    await writeFile(skillPath, rendered.body, "utf8");
+    result.rendered = true;
+    result.warnings = rendered.warnings;
+  } catch (e) {
+    result.error = `write failed: ${e.message}`;
+  }
+  return result;
+}
+async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOverride) {
+  let capabilities = {};
+  try {
+    capabilities = await loadCapabilities(workflowsDir);
+  } catch (e) {
+    return {
+      results: skillNames.map((name) => ({
+        name,
+        skillPath: join(skillsBase, name, "SKILL.md"),
+        rendered: false,
+        warnings: [],
+        error: `capabilities.yaml load failed: ${e.message}`
+      })),
+      aggregatedWarnings: [
+        `capabilities.yaml unreadable \u2014 SKILL.md placeholders left verbatim (${e.message})`
+      ]
+    };
+  }
+  const installedPlugins = readInstalledPlugins();
+  const results = [];
+  const warningSet = /* @__PURE__ */ new Set();
+  for (const name of skillNames) {
+    const r = await renderSkillFile(name, skillsBase, capabilities, installedPlugins);
+    results.push(r);
+    for (const w of r.warnings) warningSet.add(w);
+    if (r.error) warningSet.add(`${name}: ${r.error}`);
+  }
+  return { results, aggregatedWarnings: [...warningSet] };
+}
 init_checkAgentTeams();
 var FLAT_LEGACY_DEPRECATED = /* @__PURE__ */ new Set(["plan-feature", "execute-task", "verify-work"]);
 var FLAT_LEGACY_KEEP = /* @__PURE__ */ new Set(["research", "retro", "auto"]);
@@ -5026,7 +5313,10 @@ async function listBaseManifests2(pkgRoot) {
 function registerSetup(program2) {
   program2.command("setup").description(
     "One-shot onboarding: install workflow skills + base manifests to ~/.claude/ (immediate by default \u2014 use --dry-run for preview)"
-  ).option("--dry-run", "preview only \u2014 do not write to disk (opt-in for advanced users)").action(async (raw) => {
+  ).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)"
+  ).action(async (raw) => {
     const dryRun = raw.dryRun === true;
     const pkgRoot = getPackageRoot();
     const workflowsDir = resolve(pkgRoot, "workflows");
@@ -5036,7 +5326,7 @@ function registerSetup(program2) {
     try {
       entries = await readdir(workflowsDir);
     } catch {
-      console.error(`error: workflows directory not found at ${workflowsDir}`);
+      console.error(t("setup.workflows_not_found", { path: workflowsDir }));
       process.exit(1);
     }
     const { workflows: toInstall, deprecated } = await scanWorkflowsWithSkill(
@@ -5046,18 +5336,16 @@ function registerSetup(program2) {
     const depBlock = renderDeprecationBlock(deprecated);
     if (depBlock) console.log(depBlock);
     if (toInstall.length === 0) {
-      console.log("setup: no workflow directories with SKILL.md found \u2014 nothing to install");
+      console.log(t("setup.nothing_to_install"));
       process.exit(2);
     }
     if (dryRun) {
-      console.log(
-        `[dry-run] setup would install ${toInstall.length} workflow(s) to ${skillsBase}:`
-      );
+      console.log(t("setup.dry_run.header", { count: toInstall.length, path: skillsBase }));
       for (const wf of toInstall) {
         const masterTag = wf.isMaster ? " (master)" : "";
         console.log(`  ${wf.name}  \u2192  ${join(skillsBase, wf.name)}${masterTag}`);
       }
-      console.log(`  run without --dry-run to execute`);
+      console.log(t("setup.dry_run.run_hint"));
       process.exit(0);
     }
     let skillsInstalled = 0;
@@ -5070,31 +5358,68 @@ function registerSetup(program2) {
         console.log(`  [A] installed  ${wf.name}  \u2192  ${dst}${masterTag}`);
         skillsInstalled++;
       } catch (e) {
-        console.error(`  error: failed to copy ${wf.name}: ${e.message}`);
+        console.error(t("setup.copy_failed", { name: wf.name, message: e.message }));
         process.exit(1);
       }
     }
+    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 renderedCount = rendered.results.filter((r) => r.rendered).length;
     console.log(
-      `
-Step A complete: ${skillsInstalled} workflow skill(s) installed to ${skillsBase}`
+      t("setup.step_a_render.complete", {
+        count: renderedCount,
+        total: skillsInstalled
+      })
     );
+    if (rendered.aggregatedWarnings.length > 0) {
+      console.warn(t("setup.step_a_render.warnings_header"));
+      for (const w of rendered.aggregatedWarnings) {
+        console.warn(`    - ${w}`);
+      }
+    }
     const cResult = await enableAgentTeamsInSettings();
     if (cResult.status === "created") {
-      console.log(`  [C] created ${cResult.path} + enabled Agent Teams`);
+      console.log(t("setup.step_c.created", { path: cResult.path }));
     } else if (cResult.status === "already-enabled") {
-      console.log(`  [C] Agent Teams already enabled (${cResult.path})`);
+      console.log(t("setup.step_c.already_enabled", { path: cResult.path }));
     } else if (cResult.status === "enabled") {
       console.log(
-        `  [C] enabled Agent Teams in ${cResult.path} (backup saved \u2192 ${cResult.backupPath})`
+        t("setup.step_c.enabled_backup", {
+          path: cResult.path,
+          backupPath: cResult.backupPath
+        })
       );
     } else {
-      console.warn(`  [C] Agent Teams enable skipped: ${cResult.message}`);
+      console.warn(t("setup.step_c.skipped", { message: cResult.message }));
+    }
+    const dResult = await enableUserLangInSettings(raw.userLang);
+    if (dResult.status === "created") {
+      console.log(t("setup.step_d.created", { path: dResult.path, lang: dResult.detected }));
+    } else if (dResult.status === "already-set") {
+      console.log(t("setup.step_d.already_set", { path: dResult.path, lang: dResult.existing }));
+    } else if (dResult.status === "enabled") {
+      console.log(
+        t("setup.step_d.enabled_backup", {
+          path: dResult.path,
+          lang: dResult.detected,
+          backupPath: dResult.backupPath
+        })
+      );
+    } else {
+      console.warn(t("setup.step_d.skipped", { message: dResult.message }));
     }
     const manifestPaths = await listBaseManifests2(pkgRoot);
     const b = await runStepBInstall(manifestPaths);
     const stepBMs = (b.elapsedMs / 1e3).toFixed(1);
     console.log(
-      `Step B complete: ${b.installed.length} manifest(s) installed / ${b.alreadyInstalled.length} already-installed / ${b.skipped.length} skipped / ${b.failed.length} failed [parallel ${stepBMs}s]`
+      t("setup.step_b_complete", {
+        installed: b.installed.length,
+        already: b.alreadyInstalled.length,
+        skipped: b.skipped.length,
+        failed: b.failed.length,
+        seconds: stepBMs
+      })
     );
     for (const n of b.installed) console.log(`  [B] installed          ${n}`);
     for (const n of b.alreadyInstalled)
@@ -5104,41 +5429,33 @@ Step A complete: ${skillsInstalled} workflow skill(s) installed to ${skillsBase}
     for (const n of b.skipped) console.log(`  [B] skipped            ${n}`);
     for (const n of b.failed) console.error(`  [B] failed             ${n}`);
     console.log(
-      `
-setup complete: ${skillsInstalled} workflow skill(s) + ${b.installed.length + b.alreadyInstalled.length} base manifest(s) configured`
+      t("setup.complete", {
+        skills: skillsInstalled,
+        manifests: b.installed.length + b.alreadyInstalled.length
+      })
     );
     if (b.alreadyInstalled.length > 0 || b.installed.length > 0) {
-      console.log(
-        `
-MCP servers configured. Run \`/mcp\` in Claude Code to verify each server's connection status. If a server shows disconnected, restart Claude Code or check the MCP command spec.`
-      );
+      console.log(t("setup.mcp_hint"));
     }
-    console.log(
-      "\n\u2713 harnessed v3.0 \u4E09\u5C42\u6808\u65B9\u6CD5\u8BBA bundled \u2014 23 workflows (4 master + 18 sub + 1 standalone) + 6 disciplines + 10 judgments + ~83 capabilities ready"
-    );
-    console.log(
-      "  workflows in <packageRoot>/workflows/ (Pure bundled, NOT user-dir override per D-01)"
-    );
+    console.log(t("setup.bundled_summary"));
+    console.log(t("setup.bundled_location"));
     process.exit(0);
   });
 }
-
-// src/cli/status.ts
 init_harnessedRoot();
 function registerStatus(program2) {
   program2.command("status").description("Show installed upstreams (from <harnessed-root>/state.json)").action(async () => {
     const state = await readState(process.cwd());
     const names = Object.keys(state.installed).sort();
     if (names.length === 0) {
-      console.log(`no installs recorded (${harnessedFile("state.json")} absent or empty)`);
+      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(`
-${names.length} install${names.length === 1 ? "" : "s"} recorded`);
+      console.log(t("status.summary_installs", { count: names.length }));
     }
     const lockPath = harnessedFile(".lock");
     try {
@@ -5150,18 +5467,20 @@ ${names.length} install${names.length === 1 ? "" : "s"} recorded`);
         const s = await stat(lockPath);
         const ageMs = Date.now() - s.mtime.getTime();
         const stale = ageMs > 1e4;
-        console.log(`
-lock: held (since ${s.mtime.toISOString()})${stale ? " \u2014 STALE" : ""}`);
-        console.log(`  to release: wait for process to finish or delete ${lockPath}`);
+        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("\nlock: free");
+        console.log(t("status.lock_free"));
       }
     } catch {
     }
   });
 }
-
-// src/cli/uninstall.ts
 init_path_guard();
 
 // src/uninstallers/lib/runOrPreview.ts
@@ -5178,10 +5497,10 @@ var uninstallCcHookAdd = async (ctx) => {
   }
   const abort = dryRunGate(ctx);
   if (abort) return abort;
-  const settingsPath2 = join(homedir(), ".claude", "settings.json");
+  const settingsPath3 = join(homedir(), ".claude", "settings.json");
   let existing;
   try {
-    existing = await readFile(settingsPath2, "utf8");
+    existing = await readFile(settingsPath3, "utf8");
   } catch {
     return { ok: true, removedPaths: [] };
   }
@@ -5210,8 +5529,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(settingsPath2, newText);
-  return { ok: true, removedPaths: [settingsPath2] };
+  await writeFile(settingsPath3, newText);
+  return { ok: true, removedPaths: [settingsPath3] };
 };
 
 // src/uninstallers/ccPluginMarketplace.ts
@@ -5253,11 +5572,11 @@ function extractCloneTarget2(cmd) {
   const tokens = tail.split(/\s+/);
   let i = 0;
   while (i < tokens.length) {
-    const t = tokens[i];
-    if (t === void 0 || !t.startsWith("-")) break;
-    if (t === "--depth" || t === "--branch" || t === "-b") {
+    const t2 = tokens[i];
+    if (t2 === void 0 || !t2.startsWith("-")) break;
+    if (t2 === "--depth" || t2 === "--branch" || t2 === "-b") {
       i += 2;
-    } else if (t.includes("=")) {
+    } else if (t2.includes("=")) {
       i += 1;
     } else {
       i += 2;
@@ -5347,7 +5666,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((resolve10) => {
+  const result = await new Promise((resolve12) => {
     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) => {
@@ -5355,15 +5674,15 @@ var uninstallNpmCli = async (ctx) => {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve10({ exitCode: -1, stderr: `${stderr}[timeout]` });
+      resolve12({ exitCode: -1, stderr: `${stderr}[timeout]` });
     }, 3e4);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve10({ exitCode: -1, stderr: e.message });
+      resolve12({ exitCode: -1, stderr: e.message });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve10({ exitCode: code ?? -1, stderr });
+      resolve12({ exitCode: code ?? -1, stderr });
     });
   });
   if (result.exitCode !== 0) {
@@ -5417,8 +5736,8 @@ function registerUninstall(program2) {
     const yes = raw.yes === true || raw.nonInteractive === true;
     if (yes && raw.dryRun) {
       console.error(
-        `error: --yes is incompatible with --dry-run (dry-run does not mutate)
-  fix:  harnessed uninstall ${name} --yes  (immediate) OR harnessed uninstall ${name} --dry-run  (preview)`
+        `${t("uninstall.yes_dryrun_conflict")}
+${t("uninstall.yes_dryrun_conflict.fix", { name })}`
       );
       process.exit(2);
     }
@@ -5437,8 +5756,8 @@ function registerUninstall(program2) {
         chosenPath = skillPackPath;
       } catch {
         console.error(
-          `error: manifest '${resolvedName}' not found
-  fix:  ensure manifests/tools/${resolvedName}.yaml or manifests/skill-packs/${resolvedName}.yaml exists`
+          `${t("install.manifest_not_found", { name: resolvedName })}
+${t("install.manifest_not_found.fix", { name: resolvedName })}`
         );
         process.exit(1);
       }
@@ -5451,28 +5770,28 @@ function registerUninstall(program2) {
     const method = v.manifest.spec.install.method;
     const dryRun = raw.dryRun === true;
     if (dryRun) {
-      console.log(`[dry-run] would uninstall '${resolvedName}' via method '${method}'`);
-      console.log(`  run without --dry-run to execute`);
+      console.log(t("uninstall.dry_run.preview", { name: resolvedName, method }));
+      console.log(t("uninstall.dry_run.run_hint"));
       process.exit(2);
     }
     if (!yes) {
       const answer = await p.confirm({
-        message: `Uninstall '${resolvedName}'? This cannot be undone.`,
+        message: t("uninstall.confirm.prompt", { name: resolvedName }),
         initialValue: false
       });
       if (p.isCancel(answer) || answer === false) {
-        console.error(`aborted: user cancelled`);
+        console.error(t("uninstall.cancelled"));
         process.exit(2);
       }
     }
     const opts = { apply: true, dryRun: false, yes };
     const result = await runUninstall(v.manifest, opts);
     if ("aborted" in result) {
-      console.error(`aborted: ${result.reason}`);
+      console.error(t("install.aborted", { reason: result.reason }));
       process.exit(2);
     }
     if (result.ok) {
-      console.log(`uninstalled ${resolvedName}`);
+      console.log(t("uninstall.completed", { name: resolvedName }));
       process.exit(0);
     }
     console.error(`error: ${result.error}`);
@@ -5483,8 +5802,20 @@ function registerUninstall(program2) {
 // src/cli.ts
 init_harnessedRoot();
 migrateLegacyHarnessedRoot();
+var argv = process.argv;
+for (let i = 2; i < argv.length; i++) {
+  const a = argv[i];
+  if (a === "--lang" && i + 1 < argv.length) {
+    setLocale(argv[i + 1]);
+    break;
+  }
+  if (a?.startsWith("--lang=")) {
+    setLocale(a.slice("--lang=".length));
+    break;
+  }
+}
 var program = new Command();
-program.name("harnessed").description("AI coding harness package manager + composition orchestrator").version(package_default.version);
+program.name("harnessed").description("AI coding harness package manager + composition orchestrator").version(package_default.version).option("--lang <code>", "output language: en | zh (auto-detect from $LANG / Intl if absent)");
 registerInstall(program);
 registerInstallBase(program);
 registerResearch(program);