@holmes-lab/holmes-kit 0.12.2 → 0.14.0

package/dist/holmes/cli/index.js

@@ -45,6 +45,7 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const init_1 = require("./init");
 const doctor_1 = require("./doctor");
+const colophon_1 = require("./colophon");
 /**
  * `holmes-kit` CLI entry — argv dispatch, hand-rolled (no new dependency).
  *
@@ -71,7 +72,8 @@ function packageRoot() {
  * REQ-144's "cannot decide is not permission", applied to CLI arguments.
  */
 const KNOWN_FLAGS = {
-    init: ['help', 'target', 'mode', 'specs-dir', 'settings', 'matcher', 'dry-run', 'no-mcp', 'remove', 'force', 'agent', 'mcp-launcher'],
+    init: ['help', 'target', 'mode', 'specs-dir', 'settings', 'matcher', 'dry-run', 'no-mcp', 'remove', 'force', 'agent', 'mcp-launcher', 'autonomy', 'no-autonomy'],
+    autonomy: ['help', 'target', 'for'],
     doctor: ['help', 'target', 'json'],
     skills: ['help', 'target'],
     ci: ['help', 'target', 'specs-dir', 'json'],
@@ -91,16 +93,16 @@ const KNOWN_FLAGS = {
 // the whole-CLI usage over it. This set is that exemption, kept declarative so a future self-help
 // command is one edit, not a dispatch-order gamble.
 const SELF_HELP_COMMANDS = new Set(['approve']);
-const APPROVE_USAGE = `holmes-kit approve — 승인 대기 요청의 결재 (HITL)
+const APPROVE_USAGE = `holmes-kit approve — decide pending approval requests (HITL)
 
-  대화형(TTY):        항목마다 [a]승인 [e]사유·기간 지정 승인 [v]상세 [d]거부 [q]질문 [s]건너뛰기 [A]남은 전체 승인
-  --watch             상주 모드 — 요청이 도착하는 즉시 결정, 큐가 비면 대기 (Ctrl-C 로 종료, --poll-ms <밀리초>)
-  --list              대기 목록만 출력
-  --grant <참조>      해당 요청의 좁은 그랜트 발급 (--ttl <분>, --rationale <문구>)
-                      참조 = 목록 번호(1,2,…) | id | id 접두 — 긴 id를 옮겨 적을 필요가 없습니다
-  --deny <id> --reason <문구>     거부 — 사유가 에이전트의 다음 거부 문면에 실립니다
-  --ask <id> --question <문구>    질문 남기고 보류 — 에이전트가 사용자에게 전달합니다
-  --target <dir>      프로젝트 루트 (기본: 현재 디렉터리)
+  interactive (TTY):  per item [a] approve [e] approve with reason/duration [v] details [d] deny [q] ask [s] skip [A] approve all remaining
+  --watch             resident mode — decide as requests arrive, wait when the queue is empty (Ctrl-C to exit, --poll-ms <ms>)
+  --list              print the pending list only
+  --grant <ref>       issue a narrow grant for that request (--ttl <minutes>, --rationale <text>)
+                      ref = list number (1,2,…) | id | id prefix — no need to retype a long id
+  --deny <id> --reason <text>     deny — the reason rides the agent's next refusal
+  --ask <id> --question <text>    leave a question and hold — the agent relays it to the user
+  --target <dir>      project root (default: current directory)
 `;
 class UnknownFlagError extends Error {
 }
@@ -110,7 +112,7 @@ class UnknownFlagError extends Error {
  * what you'd do" spelling performed a REAL write (round-3 HIGH; same class inverted --remove and
  * --force). A boolean flag must never consume a token.
  */
-const BOOLEAN_FLAGS = new Set(['help', 'dry-run', 'no-mcp', 'remove', 'force', 'json', 'list', 'watch']);
+const BOOLEAN_FLAGS = new Set(['help', 'dry-run', 'no-mcp', 'remove', 'force', 'json', 'list', 'watch', 'autonomy', 'no-autonomy']);
 function parseFlags(argv, known) {
     const flags = {};
     const positionals = [];
@@ -190,6 +192,10 @@ const USAGE = `holmes-kit — deterministic ASE governance for a project
     --dry-run                  print the diff, write nothing
     --remove                   remove holmes-kit wiring (holmes-owned entries only)
     --force                    re-wire an already-wired target (requires HOLMES_APPROVAL)
+    --autonomy                 grant autonomous spec approval (low-risk only; governance-critical
+                               still ask you). Non-interactive: requires HOLMES_APPROVAL. At a TTY,
+                               init asks instead. Off is default; turn off with --no-autonomy.
+    --no-autonomy              keep every spec approval human (default)
 
   holmes-kit ledger rechain    re-chain forked ledger files against the committed mainline
     --target <dir>             project to repair (default: cwd)
@@ -198,7 +204,7 @@ const USAGE = `holmes-kit — deterministic ASE governance for a project
     --dry-run                  report what would be re-chained, write nothing
 
   holmes-kit approve           review pending approval requests (HITL)
-    (no flags, TTY)            interactive: [a]승인 [e]지정승인 [v]상세 [d]거부 [q]질문 [s]건너뛰기 [A]전체승인
+    (no flags, TTY)            interactive: [a]approve [e]approve-with-terms [v]details [d]deny [q]ask [s]skip [A]approve-all
     --list                     print the pending queue and exit
     --grant <ref> [--ttl <min>] [--rationale <text>]  mint the narrow grant for one request
     --deny <ref> --reason <text>                      record a denial the agent will see
@@ -206,9 +212,15 @@ const USAGE = `holmes-kit — deterministic ASE governance for a project
     <ref>                      list index (1,2,…), full id, or a unique id prefix
     --target <dir>             project root (default: cwd)
 
-  holmes-kit semantic-key set|unset|status   cloud semantic 티어 opt-in 키 관리
-                             set 은 stdin 으로만 입력받습니다(값은 argv·출력 어디에도 남지 않음).
-                             키 설정은 이그레스(스펙 산문·경로·심볼명 외부 전송) 동의입니다.
+  holmes-kit autonomy status|on|off          grant/end per-session autonomous spec approval
+    on [--for 2h]              self-drive low-risk specs this session (governance-critical still
+                               ask you); at a TTY it just asks, non-interactive needs HOLMES_APPROVAL
+    off                        end it now (always free)
+    --target <dir>             project root (default: cwd)
+
+  holmes-kit semantic-key set|unset|status   manage the cloud semantic tier opt-in key
+                             set reads from stdin only (the value never appears in argv or output).
+                             Setting the key is consent to egress (spec prose, paths, symbol names sent externally).
 
   holmes-kit doctor [flags]    diagnose the install
     --target <dir>             also verify that target's wiring points at this install
@@ -261,7 +273,8 @@ async function main(argv) {
         // Positionals these commands do not take are refused, not dropped: `skills refresh <dir>`
         // silently wrote into CWD while the named target stayed stale (round-3 HIGH).
         const expected = cmd === 'skills' ? ['refresh'] : cmd === 'ledger' ? ['rechain']
-            : cmd === 'semantic-key' ? ['set', 'unset', 'status'] : [];
+            : cmd === 'semantic-key' ? ['set', 'unset', 'status']
+                : cmd === 'autonomy' ? ['status', 'on', 'off'] : [];
         const unexpected = positionals.filter((p) => !expected.includes(p));
         if (unexpected.length > 0) {
             const hint = fs.existsSync(unexpected[0]) ? ` — did you mean --target ${unexpected[0]}?` : '';
@@ -291,11 +304,32 @@ async function main(argv) {
         process.stdout.write(`${v}\n`);
         return 0;
     }
+    // @implements A-SPEC-548.1 — a hidden maker's mark on the detective theme. Undocumented (never in
+    // USAGE); a colophon for those who go looking.
+    if (cmd === 'elementary' || cmd === 'whodunit') {
+        process.stdout.write((0, colophon_1.colophon)());
+        return 0;
+    }
     if (cmd === 'semantic-key') {
         // @implements A-SPEC-477 — set|unset|status; the key rides stdin, never argv.
         const { runSemanticKey } = await Promise.resolve().then(() => __importStar(require('./semantic-key')));
         return runSemanticKey(positionals[0]);
     }
+    // @implements A-SPEC-553.1 — session autonomy envelope: status|on [--for 2h]|off. Enabling is a
+    // foreground human act (raw-TTY proof, or an out-of-band HOLMES_APPROVAL for the non-interactive
+    // path); the marker lives in the agent-write-protected .ax/state/, so a session cannot self-grant.
+    if (cmd === 'autonomy') {
+        const { runAutonomy } = await Promise.resolve().then(() => __importStar(require('./autonomy')));
+        const root = path.resolve(typeof flags.target === 'string' ? flags.target : process.cwd());
+        const forStr = typeof flags.for === 'string' ? flags.for : undefined;
+        const r = runAutonomy(root, positionals[0], forStr, {
+            now: new Date().toISOString(),
+            isTTY: !!process.stdin.isTTY && !!process.stdout.isTTY,
+            approval: readApproval(),
+        });
+        process[r.ok ? 'stdout' : 'stderr'].write(`${r.message}\n`);
+        return r.exitCode;
+    }
     if (cmd === 'doctor') {
         // A nonexistent target read as "healthy but unwired" and both advised remedies then refused it
         // (round-6) — the typo is the diagnosis, so say it.
@@ -335,7 +369,7 @@ async function main(argv) {
         if (r.written.length)
             process.stdout.write(`Refreshed ${r.written.length} recovery skill(s) under ${path.join(target, '.claude', 'skills')}: ${r.written.map(invocableSkillName).join(', ')}\n`);
         if (r.written.length === 0 && r.skipped.length === 0 && r.failed.length === 0) {
-            // 이 패키지가 플레이북을 하나도 싣지 않았다 — 'Refreshed 0' 은 성공처럼 읽힌다.
+            // this package shipped no playbooks — 'Refreshed 0' reads like success.
             process.stderr.write(`This holmes-kit package ships no playbooks — nothing to refresh under ${path.join(target, '.claude', 'skills')}. Reinstall or upgrade holmes-kit itself.\n`);
             return 1;
         }
@@ -414,14 +448,14 @@ async function main(argv) {
         // Name a wrong --target as a wrong PATH, not as 'not a git repo' (round-12: the git error was
         // misdiagnosed) — the same class doctor's --target guard fixes.
         if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
-            process.stderr.write(`--target ${root} 는 존재하는 디렉터리가 아닙니다.\n`);
+            process.stderr.write(`--target ${root} is not an existing directory.\n`);
             return 2;
         }
         try {
             execFileSync('git', ['-C', root, 'rev-parse', '--git-dir'], { stdio: 'pipe', env: gitEnv });
         }
         catch {
-            process.stderr.write('git 저장소가 아닙니다 — 정본(ref) 없이는 재연쇄하지 않습니다: 재연쇄는 전량 재서명이며, 무엇이 정본인지는 커밋된 이력만이 말할 수 있습니다.\n');
+            process.stderr.write('not a git repository — without a canonical ref there is no rechaining: a rechain is a wholesale re-signing, and only the committed history can say what is canonical.\n');
             return 1;
         }
         // The ref is validated BEFORE the walk (round-2 finding: a typo'd --ref silently degraded the
@@ -432,7 +466,7 @@ async function main(argv) {
             execFileSync('git', ['-C', root, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`], { stdio: 'pipe', env: gitEnv });
         }
         catch {
-            process.stderr.write(`--ref ${ref} 를 커밋으로 해석할 수 없습니다 — 정본을 지정하지 못한 채로는 재연쇄하지 않습니다.\n`);
+            process.stderr.write(`--ref ${ref} cannot be resolved to a commit — without a canonical ref there is no rechaining.\n`);
             return 1;
         }
         const ledgerDir = path.join(root, '.ax', 'ledger');
@@ -444,7 +478,7 @@ async function main(argv) {
             ? fs.readdirSync(ledgerDir).filter(isLedgerFilename)
             : [];
         if (files.length === 0) {
-            process.stdout.write('원장 파일이 없습니다 — 재연쇄할 것이 없습니다.\n');
+            process.stdout.write('no ledger files — nothing to rechain.\n');
             return 0;
         }
         // STRICT parse (round-9): a torn TAIL is tolerated, but mid-file corruption or a non-object line
@@ -463,7 +497,7 @@ async function main(argv) {
             // A rev-list failure (the ref was already rev-parse-verified) is a real git error, not an
             // empty history — surface it rather than degrading every file to a false 'no mainline'
             // (round-12).
-            process.stderr.write(`git rev-list 실패 — 이력을 열거할 수 없습니다: ${e.message.split('\n')[0]}\n`);
+            process.stderr.write(`git rev-list failed — cannot enumerate history: ${e.message.split('\n')[0]}\n`);
             return 1;
         }
         // Resolve the SYMBOLIC ref once (round-13): 'HEAD' is ephemeral, so the audit event records the
@@ -482,14 +516,14 @@ async function main(argv) {
             const audited = [...r.events];
             audited.push(chainNext(audited, {
                 ts: new Date().toISOString(), actor: 'holmes-kit', kind: 'ledger-rechained',
-                summary: `rechained against ${refLabel}@${mainlineAt.slice(0, 8)} — 본선 ${mainline.length} + 고아 ${r.orphanCount}`,
+                summary: `rechained against ${refLabel}@${mainlineAt.slice(0, 8)} — mainline ${mainline.length} + orphans ${r.orphanCount}`,
                 inputs: [refLabel, mainlineAt, String(r.orphanCount)], rationale: 'ledger rechain repair', authorization: '',
             }, key));
-            // Verify the AUDITED chain (round-8: never claim "검증 통과" without verifying; round-16: verify
+            // Verify the AUDITED chain (round-8: never claim "verified" without verifying; round-16: verify
             // the chain we will actually write, WITH its keyed audit tail, not the pre-audit prefix).
             const v = verifyChain(audited, key);
             if (!v.ok)
-                return { refused: `재연쇄 산출이 검증되지 않습니다(brokenAt=${v.brokenAt ?? '?'}: ${v.detail ?? ''}) — 정본(--ref)이나 키 설정을 확인하십시오.` };
+                return { refused: `the rechained output does not verify (brokenAt=${v.brokenAt ?? '?'}: ${v.detail ?? ''}) — check the canonical ref (--ref) or the key setting.` };
             return { audited, orphanCount: r.orphanCount, alreadyVerified: false, mainlineLen: mainline.length, mainlineAt };
         };
         // "Is this committed version VALIDLY KEYED under the current key?" — the load-bearing distinction
@@ -505,7 +539,7 @@ async function main(argv) {
                 working = parse(fs.readFileSync(abs, 'utf8'), name);
             }
             catch (e) {
-                process.stdout.write(`✗ ${name}: ${e.message} — 손상 줄을 조사·복구한 뒤 다시 실행하십시오.\n`);
+                process.stdout.write(`✗ ${name}: ${e.message} — investigate and repair the corrupt line, then re-run.\n`);
                 failed++;
                 continue;
             }
@@ -513,7 +547,7 @@ async function main(argv) {
             // keyed ledger as keyless is the exact attack signature the HMAC detector exists for,
             // manufactured by the repair tool).
             if (!key && hasKeyedLookingEvents(working)) {
-                process.stdout.write(`✗ ${name}: 자기일관 아닌 줄이 있습니다 — keyed(HMAC) 이거나 content-tampered 이며 키 없이는 구별할 수 없습니다. keyed 라면 HOLMES_LEDGER_KEY 를 설정하고, 변조라면 조사하십시오. rechain 은 포크만 복구하며 이 줄을 재서명하지 않습니다.\n`);
+                process.stdout.write(`✗ ${name}: there is a non-self-consistent line — either keyed (HMAC) or content-tampered, and without the key the two cannot be told apart. If keyed, set HOLMES_LEDGER_KEY; if tampered, investigate. rechain only repairs forks and does not re-sign this line.\n`);
                 failed++;
                 continue;
             }
@@ -601,14 +635,14 @@ async function main(argv) {
             // rewrite that erases every keyed commit within WALK_LIMIT (rebase/squash) defeats this
             // git-anchored check — the fundamental limitation named in provenance-chain.ts and spec §22.
             if (mainline !== null && key && sawKeyedCommitted) {
-                process.stdout.write(`✗ ${name}: 커밋 이력이 keyed(HMAC)였는데 현재 본선 후보가 keyless입니다 — 키 채택은 되돌릴 수 없습니다(keyless-rollback). 이 재기록은 keyed 이력을 폐기하고 keyless 내용을 키로 재서명해 위조를 세탁합니다. verify 가 이미 이를 변조로 표시합니다. 건강한 keyed 정본을 --ref 로 지정하거나 변조를 조사하십시오.\n`);
+                process.stdout.write(`✗ ${name}: the committed history was keyed (HMAC) but the current mainline candidate is keyless — adopting a key is irreversible (keyless-rollback). This rewrite would discard the keyed history and re-sign the keyless content with the key, laundering a forgery. verify already flags this as tampering. Point --ref at a healthy keyed canonical, or investigate the tampering.\n`);
                 failed++;
                 continue;
             }
             if (keyedBlocked) {
                 process.stdout.write(key
-                    ? `✗ ${name}: 커밋 이력의 본선이 현재 HOLMES_LEDGER_KEY 로 검증되지 않습니다 — 키가 틀렸거나 이력이 변조됐습니다. 지나쳐 재연쇄하면 keyed 이력이 틀린 키로 재서명됩니다. 올바른 키를 확인하십시오.\n`
-                    : `✗ ${name}: 커밋 이력의 본선에 자기일관 아닌 줄이 있습니다 — keyed(HMAC) 이거나 content-tampered 입니다. keyed 라면 HOLMES_LEDGER_KEY 를 설정하고, 변조라면 조사하십시오. 지나쳐 재연쇄하지 않습니다.\n`);
+                    ? `✗ ${name}: the committed mainline does not verify under the current HOLMES_LEDGER_KEY — either the key is wrong or the history was tampered with. Rechaining past this would re-sign a keyed history with the wrong key. Confirm the correct key.\n`
+                    : `✗ ${name}: the committed mainline has a non-self-consistent line — it is keyed (HMAC) or content-tampered. If keyed, set HOLMES_LEDGER_KEY; if tampered, investigate. Not rechaining past it.\n`);
                 failed++;
                 continue;
             }
@@ -616,14 +650,14 @@ async function main(argv) {
                 // With no verifying committed mainline nothing can arbitrate. A verifying working file
                 // needs no arbitration; a broken one is refused, not guessed at.
                 if (verifyChain(working, key).ok) {
-                    process.stdout.write(`· ${name}: 커밋 이력에 검증본 없음, 작업본 검증됨 — 무변경\n`);
+                    process.stdout.write(`· ${name}: no verifying copy in the committed history, working copy verifies — no change\n`);
                     continue;
                 }
                 process.stdout.write(presentButCorrupt
-                    ? `✗ ${name}: 커밋 이력의 원장본이 손상되어 있고 작업본도 검증 실패 — 손상 커밋본을 복구하거나 건강한 정본을 --ref 로 지정하십시오\n`
+                    ? `✗ ${name}: the committed ledger copy is corrupt and the working copy fails to verify — repair the corrupt committed copy or point --ref at a healthy canonical\n`
                     : presentAnywhere
-                        ? `✗ ${name}: first-parent ${WALK_LIMIT}커밋 안에 검증되는 커밋본이 없고 작업본도 검증 실패 — 정본을 --ref 로 지정하십시오\n`
-                        : `✗ ${name}: ${ref} 이력에 없고 작업본도 검증 실패 — 정본을 --ref 로 지정하십시오\n`);
+                        ? `✗ ${name}: no verifying committed copy within the first-parent ${WALK_LIMIT} commits and the working copy fails to verify — point --ref at a canonical\n`
+                        : `✗ ${name}: not in the ${ref} history and the working copy fails to verify — point --ref at a canonical\n`);
                 failed++;
                 continue;
             }
@@ -643,10 +677,10 @@ async function main(argv) {
                     continue;
                 }
                 if (rd.alreadyVerified) {
-                    process.stdout.write(`· ${name}: 이미 검증됨 — 무변경\n`);
+                    process.stdout.write(`· ${name}: already verifies — no change\n`);
                     continue;
                 }
-                process.stdout.write(`○ ${name}: 재연쇄 대상 — 고아 ${rd.orphanCount}건 (dry-run, 미기록)\n`);
+                process.stdout.write(`○ ${name}: would rechain — ${rd.orphanCount} orphan(s) (dry-run, not written)\n`);
                 failed++;
                 continue; // drift detected → CI gate fails
             }
@@ -660,12 +694,12 @@ async function main(argv) {
                         fresh = parse(fs.readFileSync(abs, 'utf8'), name);
                     } // read inside the lock (round-8)
                     catch (e) {
-                        return { line: `✗ ${name}: ${e.message} — 손상 줄을 조사·복구한 뒤 다시 실행하십시오.`, fail: true };
+                        return { line: `✗ ${name}: ${e.message} — investigate and repair the corrupt line, then re-run.`, fail: true };
                     }
                     // Re-checked INSIDE the hold (TOCTOU): a non-self-consistent line appearing between the
                     // snapshot and the lock is either keyed or content-tampered — honest either way (round-8).
                     if (!key && hasKeyedLookingEvents(fresh)) {
-                        return { line: `✗ ${name}: 락 획득 사이에 자기일관 아닌 줄이 추가되었습니다 — keyed(HOLMES_LEDGER_KEY 설정) 이거나 변조입니다. 재서명하지 않습니다.`, fail: true };
+                        return { line: `✗ ${name}: a non-self-consistent line appeared while acquiring the lock — it is keyed (set HOLMES_LEDGER_KEY) or tampered. Not re-signing.`, fail: true };
                     }
                     // ONE judgment (round-16): rechain, chain the KEYED audit event onto the tail (the ledger's
                     // own doctrine — the audit trail must not silently change; the `ledger-rechained` event
@@ -676,7 +710,7 @@ async function main(argv) {
                     if ('refused' in plan)
                         return { line: `✗ ${name}: ${plan.refused}`, fail: true };
                     if (plan.alreadyVerified)
-                        return { line: `· ${name}: 이미 검증됨 — 무변경` };
+                        return { line: `· ${name}: already verifies — no change` };
                     const audited = plan.audited;
                     // ATOMIC rewrite: a crash mid-write must leave the old file, never a verifying prefix that
                     // the rerun's no-change guard silently accepts.
@@ -686,17 +720,17 @@ async function main(argv) {
                     fs.renameSync(tmp, abs);
                     // Confirm the ON-DISK result matches what we verified (round-15): the success line must
                     // reflect the file, not just the in-memory array — a torn/short write is reported, not
-                    // silently blessed as '검증 통과'.
+                    // silently blessed as 'verified'.
                     if (fs.readFileSync(abs, 'utf8') !== serialized) {
-                        return { line: `✗ ${name}: 재기록된 파일이 검증한 내용과 다릅니다(디스크 이상?) — 다시 실행하십시오.`, fail: true };
+                        return { line: `✗ ${name}: the rewritten file differs from what was verified (disk fault?) — re-run.`, fail: true };
                     }
-                    return { line: `✓ ${name}: 재연쇄 완료 — 본선 ${fixedMainline.length}(${mainlineAt.slice(0, 8)}) + 고아 ${plan.orphanCount}, 감사 기록 남김, 체인 검증 통과` };
+                    return { line: `✓ ${name}: rechained — mainline ${fixedMainline.length}(${mainlineAt.slice(0, 8)}) + orphans ${plan.orphanCount}, audit event recorded, chain verifies` };
                 }, { onStaleBreak: new ProvenanceChain(abs).staleBreakRecorder() });
             }
             catch (e) {
                 // Lock contention is a per-file refusal, not a crash.
                 if (e instanceof LedgerLockError) {
-                    process.stdout.write(`✗ ${name}: 원장 락을 얻지 못했습니다(다른 기록자 사용 중) — 잠시 후 다시 실행하십시오.\n`);
+                    process.stdout.write(`✗ ${name}: could not acquire the ledger lock (another writer is active) — retry shortly.\n`);
                     failed++;
                     continue;
                 }
@@ -710,7 +744,7 @@ async function main(argv) {
                     fs.rmSync(abs + '.rechain-tmp', { force: true });
                 }
                 catch { /* best-effort */ }
-                process.stdout.write(`✗ ${name}: 재기록 중 오류 — ${e.message.split('\n')[0]}. 이 파일은 건너뜁니다(다른 파일은 계속). 원인을 조사한 뒤 다시 실행하십시오.\n`);
+                process.stdout.write(`✗ ${name}: error during rewrite — ${e.message.split('\n')[0]}. This file is skipped (others continue). Investigate the cause, then re-run.\n`);
                 failed++;
                 continue;
             }
@@ -762,13 +796,13 @@ async function main(argv) {
                 return 1;
             }
             const r = grantRequest(root, ref.id, opts);
-            process.stdout.write(r.ok ? `✓ 승인 — ${ref.subject('✓ 승인 — ')}\n${ref.detail(`${r.expires} 까지 유효`)}\n` : `✗ ${r.reason}\n`);
+            process.stdout.write(r.ok ? `✓ approved — ${ref.subject('✓ approved — ')}\n${ref.detail(`valid until ${r.expires}`)}\n` : `✗ ${r.reason}\n`);
             return r.ok ? 0 : 1;
         }
         if (typeof flags.deny === 'string') {
             const reason = typeof flags.reason === 'string' ? flags.reason.trim() : '';
             if (reason === '') {
-                process.stderr.write('✗ --deny 는 --reason 이 필요합니다 — 사유 없는 거부는 에이전트가 볼 수 없습니다\n');
+                process.stderr.write('✗ --deny requires --reason — a denial with no reason is invisible to the agent\n');
                 return 1;
             }
             const ref = resolveRef(flags.deny);
@@ -777,13 +811,13 @@ async function main(argv) {
                 return 1;
             }
             const r = denyRequest(root, ref.id, reason, actor);
-            process.stdout.write(r.ok ? `✓ 거부 — ${ref.subject('✓ 거부 — ')}\n${ref.detail('거부가 기록됐습니다')}\n` : `✗ ${r.reason}\n`);
+            process.stdout.write(r.ok ? `✓ denied — ${ref.subject('✓ denied — ')}\n${ref.detail('the denial was recorded')}\n` : `✗ ${r.reason}\n`);
             return r.ok ? 0 : 1;
         }
         if (typeof flags.ask === 'string') {
             const question = typeof flags.question === 'string' ? flags.question.trim() : '';
             if (question === '') {
-                process.stderr.write('✗ --ask 는 --question 이 필요합니다\n');
+                process.stderr.write('✗ --ask requires --question\n');
                 return 1;
             }
             const ref = resolveRef(flags.ask);
@@ -792,7 +826,7 @@ async function main(argv) {
                 return 1;
             }
             const r = holdRequest(root, ref.id, question, actor);
-            process.stdout.write(r.ok ? `✓ 보류 — ${ref.subject('✓ 보류 — ')}\n${ref.detail('질문은 다음 거부 문면에')}\n` : `✗ ${r.reason}\n`);
+            process.stdout.write(r.ok ? `✓ held — ${ref.subject('✓ held — ')}\n${ref.detail('the question rides the next refusal')}\n` : `✗ ${r.reason}\n`);
             return r.ok ? 0 : 1;
         }
         // @implements A-SPEC-507.1 — stale folding is a LIST-VIEW judgment: the clock enters only
@@ -814,12 +848,12 @@ async function main(argv) {
             if (typeof flags['poll-ms'] === 'string') {
                 pollMs = Number(flags['poll-ms']);
                 if (!Number.isInteger(pollMs) || pollMs <= 0) {
-                    process.stderr.write(`✗ --poll-ms 는 양의 정수(밀리초)여야 합니다 — 받은 값: ${flags['poll-ms']}\n`);
+                    process.stderr.write(`✗ --poll-ms must be a positive integer (milliseconds) — received: ${flags['poll-ms']}\n`);
                     return 1;
                 }
             }
             if (!process.stdin.isTTY) {
-                process.stderr.write('✗ 대화형 상주 모드(--watch)는 TTY 가 필요합니다 — 스크립트에서는 --list 를 쓰십시오\n');
+                process.stderr.write('✗ interactive resident mode (--watch) requires a TTY — use --list in scripts\n');
                 return 1;
             }
             // @implements A-SPEC-497.2 — the resident surface decides on ONE raw keypress (a/d/q/s, no
@@ -911,7 +945,7 @@ async function main(argv) {
     if (cmd === 'install-push-gate') {
         const target = typeof flags.target === 'string' ? path.resolve(flags.target) : process.cwd();
         if (!fs.existsSync(path.join(target, '.git'))) {
-            process.stderr.write(`✗ ${target} 는 git 저장소가 아닙니다 — pre-push 게이트는 .git/hooks 에 설치됩니다\n`);
+            process.stderr.write(`✗ ${target} is not a git repository — the pre-push gate installs into .git/hooks\n`);
             return 1;
         }
         const { PUSH_HOOK_SIGNATURE } = require('../governance/push-gate');
@@ -922,21 +956,21 @@ async function main(argv) {
         const hookPath = path.join(effectiveHooksDir(target), 'pre-push');
         // dist/holmes/cli → three up is the package root, the same derivation server.ts uses.
         const runner = path.join(path.resolve(__dirname, '..', '..', '..'), 'bin', 'holmes-pre-push.js');
-        const script = `#!/usr/bin/env node\n// ${PUSH_HOOK_SIGNATURE} — \`npx holmes-kit install-push-gate\` 가 설치했습니다.\n`
-            + `// test-evidence 원장과 push HEAD 를 대조합니다. 로드 실패는 통과(fail-open) — 게이트 오류가 push 를 막지 않습니다.\n`
+        const script = `#!/usr/bin/env node\n// ${PUSH_HOOK_SIGNATURE} — installed by \`npx holmes-kit install-push-gate\`.\n`
+            + `// Compares the test-evidence ledger against the push HEAD. A load failure passes (fail-open) — a gate error must not block a push.\n`
             + `try { require(${JSON.stringify(runner)}); } catch { process.exit(0); }\n`;
         if (fs.existsSync(hookPath)) {
             const current = fs.readFileSync(hookPath, 'utf8');
             if (!current.includes(PUSH_HOOK_SIGNATURE)) {
-                process.stderr.write(`✗ 기존 pre-push 훅이 있고 holmes-kit 이 쓴 것이 아닙니다 — 덮지 않습니다.\n`
-                    + `  수동 병합: 기존 훅 끝에 \`node ${runner} || exit 1\` 형태로 이 게이트를 이어 붙이십시오.\n`);
+                process.stderr.write(`✗ an existing pre-push hook is present and holmes-kit did not write it — not overwriting.\n`
+                    + `  Manual merge: append this gate to the end of the existing hook as \`node ${runner} || exit 1\`.\n`);
                 return 1;
             }
         }
         fs.mkdirSync(path.dirname(hookPath), { recursive: true });
         fs.writeFileSync(hookPath, script);
         fs.chmodSync(hookPath, 0o755);
-        process.stdout.write(`✓ pre-push 증빙 게이트 설치 — ${hookPath}\n  통과 조건: test_run 원장 head == push HEAD, 초록, 실행 > 0. 우회: git push --no-verify\n`);
+        process.stdout.write(`✓ pre-push evidence gate installed — ${hookPath}\n  Passes when: test_run ledger head == push HEAD, green, executed > 0. Bypass: git push --no-verify\n`);
         return 0;
     }
     if (cmd === 'init') {
@@ -951,8 +985,8 @@ async function main(argv) {
             }
             mcpLauncher = flags['mcp-launcher'];
         }
-        // 형제 열거 오류와 같은 모양(round 7): --settings·--target 은 USAGE 와 함께 exit 2 인데
-        // --mode 만 맨몸 exit 1 이었다 — 같은 실수의 진단이 두 벌이면 스크립트가 갈린다.
+        // Same shape as the sibling-enumeration error (round 7): --settings/--target exit 2 with USAGE,
+        // but --mode alone exited a bare 1 — two diagnoses of the same mistake split a script.
         if (mode !== 'guardrail' && mode !== 'governed') {
             process.stderr.write(`unknown --mode ${mode} (guardrail|governed)\n\n${USAGE}`);
             return 2;
@@ -981,8 +1015,8 @@ async function main(argv) {
         // could change the meaning of the command line is refused rather than escaped.
         if (path.isAbsolute(specsDir) || specsDir.split(/[\\/]/).includes('..') || specsDir.startsWith('~')
             || /["'`$\\;&|<>\n\r]/.test(specsDir)) {
-            // '~' 는 셸이 확장하지 못했을 때만 남는다 — 그대로 두면 대상 안에 리터럴 '~' 디렉터리를
-            // 만들고 배선까지 그 이름으로 간다(round 8).
+            // '~' survives only when the shell failed to expand it — left as-is it makes a literal '~'
+            // directory inside the target and wires under that name (round 8).
             process.stderr.write(`--specs-dir ${specsDir} must be a plain relative path inside the target (no '..', no '~', no quotes or shell metacharacters)\n\n${USAGE}`);
             return 2;
         }
@@ -1014,8 +1048,33 @@ async function main(argv) {
             agents = ['claude', 'antigravity'];
             isAdditive = true;
         }
+        // @implements A-SPEC-552.1 — the project autonomy posture. `--autonomy`/`--no-autonomy` are the
+        // non-interactive spellings (enabling then needs an out-of-band approval, enforced in runInit);
+        // otherwise, at a real TTY, ASK — a `y` there is a human answer (autonomyInteractive), so it
+        // needs no token. Non-TTY with no flag leaves it undefined = preserve the current posture.
+        let autonomy;
+        let autonomyInteractive = false;
+        if (flags.autonomy === true) {
+            autonomy = true;
+        }
+        else if (flags['no-autonomy'] === true) {
+            autonomy = false;
+        }
+        else if (process.stdin.isTTY && process.stdout.isTTY && flags['dry-run'] !== true
+            && flags.remove !== true && flags['no-mcp'] !== true) {
+            const { promptAutonomy } = require('./interactive-prompt');
+            if (await promptAutonomy()) {
+                autonomy = true;
+                autonomyInteractive = true;
+            }
+            else {
+                autonomy = false;
+            }
+        }
         const opts = {
             agents,
+            autonomy,
+            autonomyInteractive,
             allowAdditive: isAdditive,
             target: path.resolve(typeof flags.target === 'string' ? flags.target : process.cwd()),
             packageRoot: packageRoot(),
@@ -1090,8 +1149,8 @@ async function main(argv) {
             },
         });
     }
-    // round-8: `holmes-kit --target x` 나 `holmes-kit --` 처럼 명령 자리에 플래그가 오면 exit 1,
-    // 같은 토큰이 하위 명령 뒤에 오면 exit 2 였다 — 같은 실수에 두 가지 진단.
+    // round-8: a flag in the command slot (`holmes-kit --target x` or `holmes-kit --`) exited 1,
+    // while the same token after a subcommand exited 2 — two diagnoses of the same mistake.
     process.stderr.write(cmd.startsWith('-')
         ? `unknown flag in command position: ${cmd}\n\n${USAGE}`
         : `unknown command: ${cmd}\n\n${USAGE}`);

package/dist/holmes/cli/init.d.ts

@@ -31,6 +31,8 @@ export interface InitOptions {
     agents?: Agent[];
     allowAdditive?: boolean;
     mcpLauncher?: LauncherMode;
+    autonomy?: boolean;
+    autonomyInteractive?: boolean;
 }
 export interface FileChange {
     path: string;