knodin 0.7.6 → 0.8.2

package/dist/bin/cli.js

@@ -1,109 +1,2165 @@
 #!/usr/bin/env node
-import{c as vt}from"../chunks/chunk-SIJAQVSX.js";import{$ as $t,A as at,Aa as Se,B as ct,Ba as Bt,C as ke,Ca as Ht,D as be,E as dt,F as lt,G as ut,H as ae,I as xe,J as F,K as pt,L as B,M as mt,N as ft,O as V,P as ve,Q as ht,R as gt,S as wt,T as yt,U as kt,V as bt,W as ce,X as xt,Y as $e,a as se,aa as de,b as Q,c as ye,ca as Et,d as Be,da as Rt,e as He,ea as St,f as De,g as ze,h as Ge,ha as Ct,i as Ue,ia as Ot,ja as Ee,k as Ve,ka as le,l as Ke,la as Pt,m as Je,ma as Lt,n as Ye,na as qt,o as Qe,oa as ue,p as Xe,pa as Mt,q as Ze,qa as Ft,r as et,ra as Z,s as tt,sa as jt,t as nt,ta as ee,u as ot,ua as pe,v as it,va as H,w as st,wa as Re,x as A,xa as Wt,y as rt,ya as X,z as re,za as te}from"../chunks/chunk-DMQAGX77.js";import{a as _t,b as It,c as Nt,e as Tt,f as At}from"../chunks/chunk-F4Z3Z766.js";import"../chunks/chunk-X6M4HUUE.js";import{a as Me,b as Fe,c as je,d as We}from"../chunks/chunk-YPRMY2LP.js";import{spawn as en,spawnSync as Ie}from"node:child_process";import Te from"node:fs";import W from"node:path";import $n from"node:readline/promises";import{fileURLToPath as En}from"node:url";import{spawnSync as Dt}from"node:child_process";import Ce from"node:fs";import ne from"node:path";var zt=3e4;function nn(){return{commandExists:e=>{let o=Dt(e,["--help"],{stdio:"ignore",timeout:5e3});return o.status!==null||o.error?.code!=="ENOENT"},run:(e,o)=>{let n=performance.now(),r=Dt(e[0],e.slice(1),{stdio:"ignore",timeout:zt,cwd:o});return{exitCode:r.status,elapsedMs:Math.round(performance.now()-n),timedOut:r.signal==="SIGTERM"||r.signal==="SIGKILL"}}}}function Gt(e,o,n=nn()){let r=ne.resolve(e),c=ne.join(r,".gitnexus","run.cjs"),i=[Ce.existsSync(c)?{artifact:"gitnexus",command:["node",c,"analyze"],requiredCommand:"node"}:{artifact:"gitnexus",command:["gitnexus","analyze",r],requiredCommand:"gitnexus"},{artifact:"graphify",command:["graphify","update",r],requiredCommand:"graphify"}].map(({artifact:d,command:O,requiredCommand:C})=>{if(!n.commandExists(C))return{artifact:d,state:"skipped",reason:`${d} is not installed`};let T=n.run(O,r);return T.exitCode===0?{artifact:d,state:"success",command:O,elapsedMs:T.elapsedMs}:{artifact:d,state:"failed",command:O,elapsedMs:T.elapsedMs,reason:T.timedOut?`timed out after ${zt}ms`:`exited ${T.exitCode??"unknown"}`}}),g=i.filter(d=>d.state==="success").length,b=i.filter(d=>d.state==="failed").length,$=b>0&&g===0?"failed":b>0||g>0?"partial":"skipped";return{event:o,status:$,artifacts:i}}function Ut(e,o){let n=ne.join(ne.resolve(e),".knodin");Ce.mkdirSync(n,{recursive:!0}),Ce.appendFileSync(ne.join(n,"artifact-refresh.jsonl"),`${JSON.stringify({at:new Date().toISOString(),...o})}
-`,"utf8")}import{Argument as he,Command as rn,CommanderError as Kt,Option as an}from"commander";function fe(e){return e.length-e.trimStart().length}function on(e){let o=[],n=null;for(let r of e.replaceAll("	","    ").split(`
-`)){if(r.trim()===""){n&&o.push(n),n=null,o.push(null);continue}if(n&&fe(r)>=4){n.continuations.push(r);continue}n&&o.push(n),n={first:r.trimEnd(),continuations:[]}}return n&&o.push(n),o}function me(e,o,n,r){let c=e.trim().split(/\s+/),l=[],i=o;for(let g of c){let b=i.trim().length>0?" ":"";i.length+b.length+g.length>r&&i.trim().length>0?(l.push(i.trimEnd()),i=`${n}${g}`):i+=`${b}${g}`}return i.trim().length>0&&l.push(i.trimEnd()),l}function sn(e,o){let n=" ".repeat(fe(e.first)),r=e.first.trim();if(e.continuations.length===0&&e.first.length<=o)return[e.first];let c=e.continuations.length>0?Math.min(...e.continuations.map(fe)):fe(e.first),l=[r,...e.continuations.map(g=>g.trim())].join(" ");if(e.continuations.length>0&&n.length+r.length>o*.55)return me(l,n,`${n}  `,o);let i=/\s{2,}/.exec(r);if(i?.index!==void 0){let g=r.slice(0,i.index).trimEnd(),b=l.slice(i.index+i[0].length).trim(),$=Math.max(n.length+g.length+2,c);return me(b,`${n}${g}${" ".repeat(Math.max(2,$-n.length-g.length))}`," ".repeat($),o)}if(e.continuations.length>0){let g=n.length+r.length,b=Math.max(g+2,c),$=e.continuations.map(d=>d.trim()).join(" ");return me($,`${n}${r}${" ".repeat(Math.max(2,b-g))}`," ".repeat(b),o)}return me(r,n,n,o)}function Vt(e,o){let n=o===void 0||!Number.isFinite(o)?100:Math.max(60,Math.floor(o)-1),r=on(e).flatMap(c=>c===null?[""]:sn(c,n));for(;r.at(-1)==="";)r.pop();return`${r.join(`
-`)}
-`}function cn(e,o){let n=Number(e);if(!Number.isInteger(n))throw new Kt(1,"knodin.invalidNumber",`${o.split(" ")[0]} must be an integer`);return n}function dn(e,o){let n=Number(e);if(!Number.isFinite(n))throw new Kt(1,"knodin.invalidNumber",`${o.split(" ")[0]} must be a number`);return n}function ln(e,o){return[...o,e]}function k(e,o,n){let r=new an(e,o);return n==="integer"?r.argParser(c=>cn(c,e)):n==="number"?r.argParser(c=>dn(c,e)):n==="collect"&&r.argParser(ln).default([]),r}function S(e,o,n,r){let c=e.command(o).description(n).allowExcessArguments(!1);return c.action((...l)=>r(l.at(-1))),c}function un(e){e.option("-v, --version","print the installed knodin version").addOption(k("--repo <path>","target a repository instead of the current directory")).option("--json","emit stable JSON").addOption(k("--identity <id>","select a stable symbol identity")).addOption(k("--file <path>","select a repo-relative definition file")).addOption(k("--kind <kind>","select a symbol kind")).addOption(k("--to-identity <id>","select a destination identity")).addOption(k("--to-file <path>","select a destination file")).addOption(k("--to-kind <kind>","select a destination kind")).addOption(k("--bytes <count>","bound serialized response bytes","integer")).addOption(k("--tokens <count>","bound serialized response tokens","integer")).addOption(k("--items <count>","bound serialized response items","integer")).option("--impact-mode <mode>","symbol or file impact").option("--direction <direction>","upstream, downstream, or both").addOption(k("--depth <count>","bounded traversal depth","integer")).option("--relations <kinds>","comma-separated relationship kinds").addOption(k("--min-confidence <value>","minimum edge confidence","number")).option("--limit <count>","result limit").option("--exclude-tests","exclude tests from impact").option("--data-flow","include bounded data-flow evidence")}function pn(e,o){let n=e.command("repos").description("manage a portfolio of repositories");for(let c of["discover","init","status","doctor"]){let l=S(n,`${c} <roots...>`,`${c} repositories beneath one or more roots`,o).addOption(k("--depth <count>","maximum discovery depth","integer")).option("--linked-worktrees <mode>","skip or include linked worktrees");c==="init"&&l.addOption(k("--include <selector>","include a repository id or path","collect")).addOption(k("--exclude <selector>","exclude a repository id or path","collect")).option("--manifest <path>","write or resume a portfolio manifest").option("--dry-run","report actions without changing repositories"),c==="discover"&&l.option("--signals","include bounded repository applicability signals").addOption(k("--items <count>","bound returned repositories and signal arrays","integer")).addOption(k("--bytes <count>","bound serialized response bytes","integer")).addOption(k("--tokens <count>","bound estimated response tokens","integer")).addHelpText("after",`
---signals returns hookManager, markerFiles, sanitized remotes, ciProviders, agentConfigs, and aidevTrackReferenced when known; every returned repository has signals, including {}. Inspection uses fixed documented marker/hook allowlists, reads only bounded hook configuration, and performs no network, credential, or marker-content reads. Linked worktrees inspect their own checkout when --linked-worktrees include is selected. See docs/REPOSITORIES-AND-WORKTREES.md for omissions and limits.
-`)}S(n,"search <query>","search selected repositories sequentially",o).addOption(k("--root <path>","portfolio root","collect")).addOption(k("--include <selector>","include a repository id or path","collect")).addOption(k("--exclude <selector>","exclude a repository id or path","collect")).option("--cursor <cursor>","resume from an opaque cursor").option("--allow-partial","return healthy repository results when another degrades");let r=e.command("fleet").description("deprecated repository-fleet compatibility");S(r,"init <roots...>","initialize a repository fleet",o).addOption(k("--depth <count>","maximum discovery depth","integer")).option("--worktrees <mode>","skip or include linked worktrees").option("--dry-run","report actions without mutation")}function mn(e,o){S(e,"context <task> [base]","build compact task orientation",o),S(e,"explain <symbol> [detail]","explain one ambiguity-safe symbol",o),S(e,"review [base] [detail]","review an explicit Git diff scope",o).option("--scope <scope>","unstaged, staged, all, or compare").option("--from <ref>","comparison start revision").option("--to <ref>","comparison end revision").option("--files <paths>","comma-separated repo-relative paths"),S(e,"map","show architecture communities and edges",o).option("--standard","include full map detail").addOption(k("--top <count>","maximum ranked communities","integer")).option("--sort <mode>","relevance, name, size, degree, or complexity").option("--relations <kinds>","comma-separated relationship kinds"),S(e,"wiki","write local architecture wiki pages",o).option("--force","rewrite unchanged pages"),S(e,"visualize <entry>","write a local architecture/call-flow HTML artifact",o).requiredOption("--output <path>","repo-relative HTML output path").addOption(k("--depth <count>","call-flow depth","integer")).addOption(k("--max-bytes <count>","hard artifact budget","integer")),S(e,"search <query> [limit]","hybrid symbol search",o).option("--languages <values>","comma-separated languages").option("--extensions <values>","comma-separated extensions").option("--kinds <values>","comma-separated symbol kinds").option("--path <prefix>","repo-relative path prefix").option("--tests-only","search test symbols only").option("--production-only","search production symbols only").option("--no-source","omit source snippets").addOption(k("--offset <count>","pagination offset","integer")).addOption(k("--limit <count>","result limit","integer")),S(e,"query <pattern> [targets...]","run one structured graph query",o).option("--impact-mode <mode>","symbol or file impact").option("--direction <direction>","upstream, downstream, or both").addOption(k("--depth <count>","bounded traversal depth","integer")).option("--relations <kinds>","comma-separated relationship kinds").addOption(k("--min-confidence <value>","minimum edge confidence","number")).option("--exclude-tests","exclude tests from impact").option("--data-flow","include bounded data-flow evidence").option("--limit <count>","result limit").addOption(k("--min-lines <count>","minimum line count","integer")).addOption(k("--min-complexity <count>","minimum complexity","integer")).option("--kinds <values>","comma-separated symbol kinds").option("--path <prefix>","repo-relative path prefix").option("--variable <name>","flow-analysis variable").option("--facets <values>","comma-separated architecture facets").addOption(k("--top <count>","maximum ranked results","integer")).option("--sort <mode>","result ordering"),S(e,"rename <old> <new>","preview or apply an ambiguity-safe rename",o).option("--apply","apply the verified edit").option("--no-verify","skip post-apply typecheck")}function fn(e,o){S(e,"evidence <level> <file>","deliver progressive source evidence",o).option("--continuation <handle>","resume an exact prior response").option("--baseline-hash <sha256>","complete baseline SHA-256").addOption(k("--baseline-bytes <count>","complete baseline UTF-8 bytes","integer")).addOption(k("--start <line>","first source line","integer")).addOption(k("--end <line>","last source line","integer"));let n=e.command("pack").description("export bounded portable context");n.argument("[input]").option("--format <format>","markdown, json, or xml").option("--include <globs>","comma-separated include globs").option("--exclude <globs>","comma-separated exclude globs").option("--policy <assignments>","comma-separated glob policies").option("--already-present <paths>","comma-separated paths already in context").option("--chat-files <paths>","comma-separated chat paths").option("--line-numbers","include source line numbers").option("--tree","include repository tree").option("--output <path>","write a repo-relative retained artifact").option("--diff-scope <scope>","unstaged, staged, all, or compare").option("--from <ref>","comparison start revision").option("--to <ref>","comparison end revision").addOption(k("--log <count>","include recent commits","integer")).action((...c)=>o(c.at(-1))),S(n,"read <artifact>","read a retained context artifact",o).addOption(k("--start <line>","first line","integer")).addOption(k("--end <line>","last line","integer")),S(n,"grep <artifact> <regex>","search an artifact with a linear-time regex",o).option("--flags <flags>","regular-expression flags").addOption(k("--limit <count>","match limit","integer"));let r=e.command("compress").description("compress already-produced output");r.argument("[input]").option("--strategy <strategy>","smart, head-tail, or errors-only").option("--adapter <adapter>","structured output adapter").addOption(k("--lines <count>","hard line budget","integer")).addOption(k("--max-output-bytes <count>","hard output byte budget","integer")).addOption(k("--context <count>","signal context lines","integer")).addOption(k("--exit-code <code>","source process exit code","integer")).option("--signal <name>","source process termination signal").addOption(k("--max-input-bytes <count>","hard input byte limit","integer")).option("--no-retain","do not retain raw drill-down data").option("--no-redact","disable secret redaction").action((...c)=>o(c.at(-1)));for(let c of["read","diagnose"])S(r,`${c} <artifact>`,`${c} a retained output artifact`,o).addOption(k("--start <line>","first line","integer")).addOption(k("--end <line>","last line","integer")).addOption(k("--max-output-bytes <count>","hard output byte budget","integer")).addOption(k("--context <count>","diagnostic context lines","integer")).addOption(k("--limit <count>","diagnostic result limit","integer")).addOption(k("--offset <count>","resume retained diagnostics at offset","integer")).option("--raw","return unredacted retained bytes");S(r,"delete <artifact>","delete a retained output artifact",o)}function Oe(e=()=>{}){let o=new rn("knodin").description("knodin \u2014 source-evidenced local code intelligence with known bounds").showHelpAfterError().showSuggestionAfterError().passThroughOptions(!1).allowExcessArguments(!1).exitOverride();o.configureOutput({writeErr:()=>{}}),un(o),o.addHelpText("after","\nMCP callers use the `prs` operation and corresponding operations on the single `knodin` gateway.\nknodin update status|check|explain|apply|rollback consumes only threshold-signed metadata.\n"),S(o,"init","initialize graph, lifecycle hooks, and agent integration",e).option("--scope <scope>","personal, team, or cli-only").addHelpText("after",`
-Usage: knodin init [--scope personal|team|cli-only] [--json]
-
-personal  recommended; local/excluded agent adapters and a clean Git status
-team      commit-ready shared agent configuration
-cli-only  no agent discovery; AI agents will not know to invoke knodin
-
-Change later with \`knodin configure --scope <scope>\`.
-Tracked files are never added to Git exclude files.
-`),S(o,"configure","change or inspect agent integration",e).option("--scope <scope>","personal, team, or cli-only").option("--status","inspect configuration without changing it"),S(o,"index [files...]","index a repository or selected files",e).option("--clean","rebuild selected index state").option("--force","force clean indexing").option("--scip <file>","opt in to a bounded local SCIP protobuf import"),S(o,"doctor","diagnose installation, clients, hooks, graph, and updates",e).option("--client <client>","claude, codex, gemini, or antigravity"),S(o,"status","report graph, lifecycle, integration, and update state",e).option("--deep","run a full graph audit").option("--watch","stream status snapshots").addOption(k("--interval <seconds>","watch interval","number")),S(o,"wait","wait for current graph evidence",e).option("--fresh","wait for a fresh graph").addOption(k("--timeout <seconds>","deadline","number")),S(o,"repair","audit and reconcile graph state",e).option("--plan","report the repair plan without mutation").option("--jsonl","stream JSONL progress").option("--progress <mode>","tty, jsonl, plain, or none").option("--progress-interval <duration>","progress interval such as 750ms, 30s, or 2m"),S(o,"serve","run the one-tool MCP gateway on stdio",e),S(o,"version","print the installed knodin version",e),S(o,"hook-refresh <kind> [values...]","internal Git lifecycle refresh",e),S(o,"refresh-artifacts [event]","refresh external graph artifacts",e),pn(o,e),mn(o,e),fn(o,e);let n=o.command("system").description("inspect declared multi-repository systems");S(n,"list","list configured systems",e);for(let i of["show","validate","query"]){let g=S(n,`${i} <system-id>`,`${i} one configured system`,e);i==="query"&&g.option("--allow-partial","return healthy components")}return o.command("update").description("inspect or apply threshold-signed updates").allowExcessArguments(!1).addArgument(new he("<action>").choices(["status","check","explain","apply","rollback"])).action((...i)=>e(i.at(-1))),S(o,"docs <topic>","read canonical product documentation",e),S(o,"prs [action]","audit pull requests, reviews, and checks",e).option("--state <state>","open, merged, closed, or all").addOption(k("--limit <count>","pull-request limit","integer")).option("--branches <pattern>","branch-name pattern").option("--range <range>","pull-request number range").option("--base <ref>","audit base revision").option("--head <ref>","audit head revision").option("--expected-login <login>","expected GitHub identity"),S(o,"worktrees [action] [path]","inspect, reconcile, or remove managed worktrees",e).option("--dry-run","report removal without mutation"),o.command("telemetry").description("manage local opt-in ROI telemetry").allowExcessArguments(!1).addArgument(new he("<action>").choices(["status","report","export","clear"])).option("--input <path>","telemetry input path").option("--output <path>","dashboard or evidence-bundle output path").addOption(k("--retention-days <count>","retention window in days","integer")).action((...i)=>e(i.at(-1))),o.command("diagnostics").description("manage local troubleshooting diagnostics and support bundles").allowExcessArguments(!1).addArgument(new he("<action>").choices(["enable","status","collect","inspect","clear","disable"])).addArgument(new he("[bundle]")).addOption(k("--retention-days <count>","local event retention in days","integer")).option("--since <duration>","collection window, such as 24h or 7d").option("--output <path>","repository-contained .json.gz bundle path").action((...i)=>e(i.at(-1))),o}function hn(e){return e.flatMap(o=>Array.isArray(o)?o:[o]).filter(o=>typeof o=="string")}function Jt(e){let o,n=Oe(l=>{o=l});if(n.parse([process.execPath,"knodin",...e]),!o)return{commandPath:[],positionals:[],options:n.opts()};let r=o,c=[];for(let l=r;l?.parent;l=l.parent)c.unshift(l.name());return{commandPath:c,positionals:hn(r.processedArgs),options:r.optsWithGlobals()}}function ge(e,o){let r=Oe();for(let l of e){let i=r.commands.find(g=>g.name()===l);if(!i)throw new Error(`knodin: unknown help command ${e.join(" ")}`);r=i}r.configureHelp({helpWidth:Math.max(60,Math.floor(o??100)-1)});let c="";return r.configureOutput({writeOut:l=>c+=l,writeErr:()=>{}}),r.outputHelp(),Vt(c,o)}function Yt(e){let o=Oe(),n=[],r=o;for(let c=0;c<e.length;c++){let l=e[c];if(l==="-h"||l==="--help")break;if(l.startsWith("-")){let g=l.split("=",1)[0],b=r,$;for(;b&&!$;)$=b.options.find(d=>d.short===g||d.long===g),b=b.parent;$?.required&&!l.includes("=")&&c++;continue}let i=r.commands.find(g=>g.name()===l);if(!i)break;r=i,n.push(l)}return n}import{execFileSync as gn}from"node:child_process";import wn from"node:crypto";import K from"node:fs";import j from"node:path";var yn=32768,kn=4096,_e=20;function P(e){return e.replaceAll("&","&amp;").replaceAll("<","&lt;").replaceAll(">","&gt;").replaceAll('"',"&quot;")}function bn(e){try{return gn("git",["rev-parse","HEAD"],{cwd:e,encoding:"utf8",stdio:["ignore","pipe","ignore"]}).trim()}catch{return"unavailable"}}function xn(e,o){if(!o||j.extname(o).toLowerCase()!==".html")throw new Error("knodin visualize: --output must be a repository-relative .html path");let n=j.resolve(e,o);if(n===e||!n.startsWith(`${e}${j.sep}`))throw new Error("knodin visualize: output path must stay inside the repository");let r=K.lstatSync(n,{throwIfNoEntry:!1});if(r?.isSymbolicLink())throw new Error("knodin visualize: output path may not be a symlink");if(r&&!K.realpathSync(n).startsWith(`${e}${j.sep}`))throw new Error("knodin visualize: output path may not follow a symlink outside the repository");let c=j.dirname(n);for(;!K.existsSync(c)&&c!==e;)c=j.dirname(c);let l=K.realpathSync(c);if(l!==e&&!l.startsWith(`${e}${j.sep}`))throw new Error("knodin visualize: output path may not traverse a symlink outside the repository");return{absolute:n,relative:j.relative(e,n).replaceAll(j.sep,"/")}}function vn(e){let o=e.communities.map(c=>{let l=(c.files??[]).slice(0,12).join(", ")||"no file detail returned",i=(c.symbols??[]).slice(0,12).join(", ")||"no symbol detail returned";return`<details><summary>${P(c.name)} <span>${c.size} symbols</span></summary><p>Cohesion: ${c.cohesion.toFixed(3)}</p><p><strong>Files:</strong> ${P(l)}</p><p><strong>Symbols:</strong> ${P(i)}</p></details>`}).join(`
-`),n=(c,l)=>l.map(i=>{let g="degree"in i?`degree ${i.degree}`:`betweenness ${i.betweenness.toFixed(3)}`;return`<li><strong>${c}</strong> ${P(i.symbol)} \u2014 ${P(g)}; ${P(i.filePath||"unresolved file")} (${P(i.communityId??"unassigned")})</li>`}).join(`
-`),r=c=>c.map(l=>`<li data-evidence="${l.label}"><code>${P(l.from)}</code> \u2192 <code>${P(l.to)}</code> <span>${P(l.kind)}</span><br><small>${l.label==="exact"?"Source evidence":"Heuristic source evidence"}: ${P(l.evidence)}</small></li>`).join(`
-`)||"<li>No bounded source-evidenced relationships were returned.</li>";return`<!doctype html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>knodin architecture visualization</title><style>body{font:16px system-ui,sans-serif;margin:2rem auto;max-width:74rem;color:#172033;background:#f6f8fb;line-height:1.45}section{background:#fff;border:1px solid #d9dee7;border-radius:.55rem;padding:1rem 1.25rem;margin:1rem 0}details{border-top:1px solid #e5e9ef;padding:.6rem 0}summary{cursor:pointer;font-weight:650}summary span,small{color:#526170}li{margin:.55rem 0}code{background:#edf1f6;padding:.1rem .3rem;border-radius:.2rem;overflow-wrap:anywhere}[data-evidence=heuristic]{border-left:3px solid #d18a00;padding-left:.55rem}</style></head>
-<body><h1>knodin local architecture visualization</h1><p>Generated locally from the persisted knodin graph. Source commit <code>${P(e.commit)}</code>; Index freshness <code>${P(e.freshness)}</code>; ${e.truncated?"some lists are bounded by the artifact budget.":"all displayed lists fit the requested artifact budget."}</p>
-<section><h2>Subsystem drill-down</h2>${o||"<p>No communities were returned.</p>"}</section>
-<section><h2>Hub and bridge inspection</h2><ul>${n("Hub",e.hubs)}${n("Bridge",e.bridges)}</ul></section>
-<section><h2>Architecture relationships</h2><ul>${r(e.architectureEdges)}</ul></section>
-<section><h2>Call-flow navigation</h2><p>Static downstream traversal from <code>${P(e.entry)}</code>, depth ${e.depth}; this is not a runtime trace.</p><ul>${r(e.callFlowEdges)}</ul></section>
-</body></html>
-`}async function Qt(e,o,n){let r=K.realpathSync(o),c=xn(r,n.outputPath),l=n.entry.trim();if(!l)throw new Error("knodin visualize: an entry selector is required");let i=n.depth??3;if(!Number.isInteger(i)||i<1||i>6)throw new Error("knodin visualize: --depth must be an integer from 1 through 6");let g=n.byteBudget??yn;if(!Number.isInteger(g)||g<kn||g>65536)throw new Error("knodin visualize: --max-bytes must be an integer from 4096 through 65536");let[b,$]=await Promise.all([e.map(r,"standard",{topN:12,sort:"name"}),e.query("traverse",l,r,void 0,_e,i,"standard",n.selector,void 0,{direction:"downstream",relationKinds:["call"],includeDataFlow:!0})]);if($.ambiguity||$.count===0)throw new Error("knodin visualize: entry selector did not resolve to a traversable symbol");let d=b.edges.filter(_=>!!_.sourceEvidence).slice(0,_e).map(_=>({from:_.from,to:_.to,kind:_.kind,evidence:_.sourceEvidence??"",label:_.confidenceLabel==="heuristic"||_.provenance!=="EXTRACTED"?"heuristic":"exact"})),O=($.edges??[]).slice(0,_e).map(_=>({from:_.from,to:_.to,kind:_.kind??"call",evidence:_.dataFlow?.evidence??`${_.fromFile??"unresolved file"}:${_.line??"unknown line"}`,label:_.dataFlow?.heuristic||_.provenance==="INFERRED"?"heuristic":"exact"})),C=b.communities.slice(0,12),T=b.hubs.slice(0,10),u=b.bridges.slice(0,10),x=d,w=O,L=!!$.truncated,D="";for(;D=vn({commit:bn(r),freshness:b.staleness??"unknown",communities:C,hubs:T,bridges:u,architectureEdges:x,callFlowEdges:w,entry:l,depth:i,truncated:L}),!(Buffer.byteLength(D)<=g);)if(L=!0,x.length)x=x.slice(0,-1);else if(w.length)w=w.slice(0,-1);else if(C.length)C=C.slice(0,-1);else if(T.length)T=T.slice(0,-1);else if(u.length)u=u.slice(0,-1);else throw new Error("knodin visualize: budget is too small for visualization metadata");return K.mkdirSync(j.dirname(c.absolute),{recursive:!0}),K.writeFileSync(c.absolute,D),{outputPath:c.relative,bytes:Buffer.byteLength(D),sha256:wn.createHash("sha256").update(D).digest("hex"),byteBudget:g,truncated:L,indexFreshness:b.staleness??"unknown",callFlow:{entry:l,depth:i,edgeCount:w.length,truncated:!!$.truncated}}}function we(e){let o=e.indexOf("--scope");if(o>=0){let r=e[o+1];if(!r)throw new Error("knodin: --scope requires a value");return se(r)}let n=e.find(r=>r.startsWith("--scope="));return n?se(n.slice(8)):null}async function Rn(e,o){let n=we(e);if(n)return n;if(xt(o))return process.stderr.write(`[init:scope] Detected tracked knodin team integration; preserving team scope
-`),"team";if(!process.stdin.isTTY||!process.stderr.isTTY)return"personal";let r=$n.createInterface({input:process.stdin,output:process.stderr});try{let c=await r.question(["How should knodin integrate with coding agents?","  1. Personal (recommended) \u2014 all detected agents; Git stays clean","  2. Team \u2014 create commit-ready shared configuration","  3. CLI-only \u2014 agents will not discover or invoke knodin automatically","Select [1]: "].join(`
-`));if(!c.trim()||c.trim()==="1")return"personal";if(c.trim()==="2")return"team";if(c.trim()==="3"){let l=await r.question("CLI-only requires manual knodin commands. Continue? [y/N] ");if(!/^y(?:es)?$/i.test(l.trim()))throw new Error("knodin init: CLI-only selection cancelled");return"cli-only"}return se(c.trim())}finally{r.close()}}function Xt(e){let o=bt(e)?.agents??[],n=ce(e)?.agents??[];return[...new Set([...Q(),...o,...n])]}function Sn(e){let o=e.paths.scope==="cli-only"?"CLI-only \u2014 AI agents are not configured to discover knodin":e.paths.agentIntegration.configured.length>0?`${e.paths.scope} \u2014 ${e.paths.agentIntegration.configured.join(", ")}`:`${e.paths.scope} \u2014 no supported coding agents detected`,n=e.paths.agentIntegration.failed.map(({agent:c,message:l})=>`
-Agent warning (${c}): ${l}`).join(""),r=e.paths.lifecycleRefresh.state==="fresh"?"fresh":`still running (${e.paths.lifecycleRefresh.queuedEvents} queued event(s)); run \`knodin wait --fresh\``;return`${e.message}
-Graph: ${e.paths.database}
-Git refresh: ${e.paths.gitHooks.length} lifecycle hooks installed; ${r}
-Agent integration: ${o}${n}
-Background indexer: ${e.paths.backgroundIndexer}
-`}function Cn(e){return e.scope==="unconfigured"?"Agent integration: unconfigured.\nWarning: AI agents will not discover or invoke knodin automatically. Run `knodin configure --scope personal`.\n":e.scope==="cli-only"?"Agent integration: CLI-only.\nWarning: AI agents will not discover or invoke knodin automatically. Run `knodin configure --scope personal` or `--scope team` to enable them.\n":e.scope==="repository-detected"?`Agent integration: repository-detected${e.agents.length>0?` (${e.agents.join(", ")})`:""}.
-Local scope receipt: missing; managed repository integration is present.
-`:`Agent integration: ${e.scope}${e.agents.length>0?` (${e.agents.join(", ")})`:""}.
-`}function On(e){let o="none detected";e.paths.agentIntegration.configured.length>0?o=e.paths.agentIntegration.configured.join(", "):e.paths.scope==="cli-only"&&(o="none (CLI-only)");let n=e.paths.agentIntegration.failed.map(({agent:i,message:g})=>`
-Agent warning (${i}): ${g}`).join(""),r=e.paths.lifecycleRefresh.state==="fresh"?"fresh":`still running (${e.paths.lifecycleRefresh.queuedEvents} queued event(s))`,c=e.paths.filesystemChanges.map(({path:i,action:g})=>`
-Filesystem ${g}: ${i}`).join(""),l=e.paths.externalConfigurationOutcomes.map(({system:i,state:g})=>`
-External configuration outcome: ${i} ${g} (external mutation not locally observable)`).join("");return`${e.message}
-Agent integration: ${e.paths.scope} \u2014 ${o}${n}${c}${l}
-Graph initialization: unchanged
-Lifecycle refresh: ${r}
-Next: ${e.nextAction}
-`}function _n(e){let o=e.after.coverage;return e.cancelled?`Repair paused: ${e.remaining??0} file(s) remaining. Run \`knodin repair\` again to finish.
-`:e.verified?e.lifecycle?.status==="degraded"?`Repair verified: graph is healthy (${o.indexedFiles} indexed files, ${o.filesWithSymbols} files with symbols), but lifecycle routing is degraded. Run \`knodin init\`, then \`knodin status\`.
-`:`Repair verified: graph is healthy (${o.indexedFiles} indexed files, ${o.filesWithSymbols} files with symbols).
-`:"Repair finished with remaining issues. Run `knodin status --deep` for details.\n"}function In(e){if(e.indexed.length===0&&e.unchanged.length>0){let r=e.unchanged.length===1?"file":"files";return`Graph already current: ${e.unchanged.length.toLocaleString()} requested ${r} needed no work; health verified.
-`}let o=e.unchanged.length>0?`; ${e.unchanged.length.toLocaleString()} already current`:"",n=e.indexed.length===1?"file":"files";return`Index complete: ${e.indexed.length.toLocaleString()} ${n} indexed${o}; graph health verified.
-`}function Nn(e){let o=e.verification.missing.files[0]??e.verification.missing.records[0],n=o?` First issue: ${o}.`:"";return`knodin index: requested work completed, but ${e.verification.issueCount.toLocaleString()} graph issue(s) remain.${n} Run \`knodin repair\`.
-`}function Tn(e){let o=`${e.coverage.sourceFiles} source files, ${e.coverage.indexedFiles} indexed files, ${e.coverage.filesWithSymbols} files with symbols`;if(e.status==="indexing"&&e.activity){let C=e.activity.phaseTotal===void 0?"":` ${e.activity.phaseCompleted}/${e.activity.phaseTotal}`,T=Math.max(0,Math.floor((Date.now()-Date.parse(e.activity.startedAt))/1e3));return`Graph update in progress: ${e.activity.phase}${C} \u2014 ${e.activity.message} (${T}s elapsed; ${o}).
-`}let n=e.integration,r=n?`Agent integration: ${n.scope}${n.agents.length>0?` (${n.agents.join(", ")})`:""}.
-`:"Agent integration: unconfigured. AI agents will not discover knodin automatically; run `knodin configure --scope personal`.\n",c=e.lifecycle?e.lifecycle.status==="healthy"?`Hooks: installed and executable.
-`:`Lifecycle refresh: ${e.lifecycle.status}; ${e.lifecycle.issues[0]??"refresh capability is not verified"}. Run \`knodin init\`.
-`:"",l=C=>C?.slice(0,12)??"unknown",i=e.freshness.commitDistance===null?"":` by ${e.freshness.commitDistance.toLocaleString()} commit(s)`,g=`Freshness: ${e.freshness.state}; indexed ${l(e.freshness.indexedHead)}, current ${l(e.freshness.currentHead)} (${e.freshness.commitRelation}${i}); ${e.freshness.workingTree.pendingPaths??"unknown"} pending path(s).
-Last successful refresh: ${e.freshness.lastSuccessfulRefresh??"never"}.
-`;if(e.status==="healthy")return`Graph content is healthy: ${o} (knodin ${e.version}; ${e.verification.mode}).
-${g}${c}${r}`;if(e.status==="stale")return`Graph content is intact but evidence is stale (${o}).
-${g}${c}${r}Run \`knodin wait --fresh\` or issue a graph query to reconcile bounded drift.
-`;let b=e.missing.files.length+e.missing.records.length,$=e.missing.files[0]??e.missing.records[0],d=$?` First issue: ${$}.`:"",O=e.lifecycle?.status==="degraded"&&e.missing.records.every(C=>e.lifecycle?.issues.includes(C))?"Run `knodin init`.":"Run `knodin repair`.";return`Graph or lifecycle needs repair: ${b} issue(s) found (${o}).${d} ${O}
-${c}${r}`}function ie(e){return e.replace(/([a-z])([A-Z])/g,"$1 $2")}function Ae(e,o="",n){if(e===null||typeof e!="object")return[`${o}${n?`${ie(n)}: `:""}${String(e)}`];if(Array.isArray(e)){if(e.length===0)return n?[]:[`${o}(none)`];let l=n?[`${o}${ie(n)}:`]:[];for(let i of e)i===null||typeof i!="object"?l.push(`${o}  - ${String(i)}`):l.push(...Ae(i,`${o}  - `));return l}let r=Object.entries(e).filter(([l])=>l!=="responseBudget"),c=n?[`${o}${ie(n)}:`]:[];for(let[l,i]of r)i===null||typeof i!="object"?c.push(`${o}${n?"  ":""}${ie(l)}: ${String(i)}`):c.push(...Ae(i,`${o}${n?"  ":""}`,l));return c}function oe(e,o){return`${[`${ie(e)}:`,...Ae(o,"  ")].join(`
-`)}
-`}function An(e){let n=`Compressed output; ${e.omittedRanges.reduce((l,i)=>l+i.lineCount,0)} line(s) omitted.`;e.status==="insufficient-budget"?n=`INSUFFICIENT BUDGET: ${e.fidelity.unpreservedSignals.length} detected signal line(s) are available only through retained drill-down.`:e.complete&&(n="Complete output; nothing omitted.");let r=e.artifact.retained?` Retained artifact: ${e.artifact.id} (${e.artifact.path}).`:" Raw retention disabled; omitted regions cannot be retrieved.";return`${e.content?`${e.content}
-`:""}---
-${n} ${e.output.lines}/${e.input.lines} lines, ${e.output.bytes}/${e.input.bytes} bytes; exit=${e.exit.code??"unknown"}, signal=${e.exit.signal??"none"}.${r}
-`}function Pn(e){let o=e.content?`${e.content}
-`:"",n=e.raw?"UNREDACTED raw view":`${e.secretRedactions} secret(s) redacted`;return`${o}---
-Artifact ${e.artifactId}, lines ${e.range.startLine}-${e.range.endLine} of ${e.range.totalLines}; ${e.bytes}/${e.byteBudget} bytes; ${n}.
-`}function Ne(e,o){if(o.length===0)return`${e}: none`;let n=o.map(({symbol:r,file:c,line:l})=>{let i=c?` (${c}:${l??"?"})`:"";return`${r}${i}`});return`${e}: ${n.join(", ")}`}function Ln(e){let o=[`Failure diagnosis: ${e.status}; ${e.diagnostics.length} resolved, ${e.unresolved.length} unresolved.`,`Freshness: ${e.freshness.state}; indexed=${e.freshness.indexedHead??"unknown"}; current=${e.freshness.currentHead??"unknown"}.`];for(let n of e.diagnostics){let r=`${n.file}:${n.reference.line??"?"}`,c=n.owner?.identity?` [${n.owner.identity}]`:"",l=`${n.owner?.symbol??"no owning symbol"}${c}`,i=n.package?`${n.package.name??"unnamed"} (${n.package.kind}, ${n.package.manifest})`:"none";o.push("",`${r} -> ${l}`,`Package: ${i}`,Ne("Tests",n.tests),Ne("Upstream",n.upstream),Ne("Downstream",n.downstream));let g=e.contextBundle.snippets.find(({file:b})=>b===n.file);g&&o.push(g.content)}for(let n of e.unresolved){let r=n.candidates?` (${n.candidates.join(", ")})`:"";o.push("",`Unresolved ${n.reference.path}: ${n.reason}${r}`)}return o.push("",...e.limitations.map(n=>`Limitation: ${n}`)),`${o.join(`
-`)}
-`}async function qn(e){let o=[],n=0;for await(let r of process.stdin){let c=Buffer.isBuffer(r)?r:Buffer.from(String(r));if(n+=c.byteLength,n>e)throw new Error(`knodin compress: input exceeded bounded retention limit of ${e} bytes`);o.push(c)}return Buffer.concat(o).toString("utf-8")}var Mn="\r\x1B[2K",Fn=2e3;function tn(e,o){let n=En(import.meta.url),r=n.endsWith(".ts")?".ts":".js",c=W.dirname(n);for(;!Te.existsSync(W.join(c,"package.json"))&&c!==W.parse(c).root;)c=W.dirname(c);let l=r===".ts"?W.resolve(W.dirname(n),`../src/${e}.ts`):W.resolve(c,`dist/src/${e}.js`),i=r===".ts"&&W.basename(process.execPath).startsWith("node")?[...process.execArgv,l]:[l],g=en(process.execPath,i,{stdio:["pipe","ignore","inherit"],env:{...process.env,KNODIN_FORCE_PROGRESS_TTY:"1"}}),b=!1,$=new Promise(O=>{g.once("close",()=>O()),g.once("error",()=>O())});g.once("error",()=>{b=!0}),g.stdin.once("error",()=>{b=!0});let d=O=>{if(!(b||g.stdin.destroyed))try{g.stdin.write(`${JSON.stringify(O)}
-`)}catch{b=!0}};return{start:()=>d(o),onProgress:O=>d({type:"progress",event:O}),stop:async()=>{d({type:"stop"}),g.stdin.end();let O=C=>new Promise(T=>{let u=!1,x=L=>{u||(u=!0,clearTimeout(w),T(L))},w=setTimeout(()=>x(!1),C);w.unref(),$.then(()=>x(!0))});await O(Fn)||(g.kill("SIGKILL"),await O(500)||g.unref()),process.stderr.write(Mn)}}}function Zt(e="init"){if(process.stderr.isTTY!==!0){let o=vt({stderr:process.stderr,operation:e});return{start:()=>o.start(),onProgress:n=>o.onProgress(n),stop:async()=>o.stop()}}return tn("init-progress-worker",{type:"start",operation:e})}async function jn(){let e=process.argv.slice(2);if(e[0]==="__repository-init-worker"){if(e.length!==2||!W.isAbsolute(e[1]))throw new Error("knodin internal repository init worker requires one absolute path");let t=await Te.promises.realpath(e[1]),s=setInterval(()=>{process.send?.({type:"rss",rssBytes:process.memoryUsage().rss})},50);s.unref(),process.send?.({type:"rss",rssBytes:process.memoryUsage().rss});let a=B();try{let p=H(t),h=(await ee([t],{depth:0,include:[t],command:ye(process),index:m=>a.index(m),status:m=>a.status(m),agents:Q(),indexMode:m=>te(p,m)})).results.find(({repository:m})=>m===t);if(!h)throw new Error("repository init worker produced no repository result");process.send?.({type:"rss",rssBytes:process.memoryUsage().rss}),process.send?.({type:"result",result:h}),h.status==="failed"&&(process.exitCode=1)}finally{clearInterval(s),await a.close()}return}let{rest:o}=Be(e),[n,...r]=o;if(!n||n==="-h"||n==="--help"){process.stdout.write(ge([],process.stdout.isTTY?process.stdout.columns:void 0));return}if(n==="-v"||n==="--version"||n==="version"){process.stdout.write(`${F}
-`);return}if(e.some(t=>t==="-h"||t==="--help")){process.stdout.write(ge(Yt(e),process.stdout.isTTY?process.stdout.columns:void 0));return}let c=Jt(e),l=t=>t.slice(2).replace(/-([a-z])/g,(s,a)=>a.toUpperCase()),i=t=>{let s=c.options[l(t)];return typeof s=="string"||typeof s=="number"?String(s):void 0},g=i("--repo"),b=ye(process),$=c.options.json===!0||n==="hook-refresh",d=n==="repair"?r:r.filter(t=>t!=="--json"),O={identity:i("--identity"),file:i("--file"),kind:i("--kind"),toIdentity:i("--to-identity"),toFile:i("--to-file"),toKind:i("--to-kind")},C={bytes:i("--bytes")?Number(i("--bytes")):void 0,tokens:i("--tokens")?Number(i("--tokens")):void 0,items:i("--items")?Number(i("--items")):void 0};for(let[t,s,a]of[["--bytes",C.bytes,256],["--tokens",C.tokens,64],["--items",C.items,1]])if(s!==void 0&&(!Number.isInteger(s)||s<a))throw new Error(`knodin: ${t} must be an integer >= ${a}`);if(n==="init"){we(r);let t=r.filter((s,a)=>!(s==="--json"||s.startsWith("--scope=")||s==="--scope"||r[a-1]==="--scope"));if(t.length>0)throw new Error(`knodin init: unknown option: ${t[0]}`)}if(n==="configure"){let t=r.includes("--status"),s=we(r),a=r.filter((p,f)=>!(p==="--json"||p==="--status"||p.startsWith("--scope=")||p==="--scope"||r[f-1]==="--scope"));if(a.length>0)throw new Error(`knodin configure: unknown option: ${a[0]}`);if(t&&s)throw new Error("knodin configure: --status and --scope are mutually exclusive");if(!t&&!s)throw new Error("knodin configure requires --scope personal|team|cli-only or --status")}if(n==="serve"){let{startServer:t}=await import("../chunks/server-7EDF4CBY.js");await t();return}if(n==="fleet"){if(g!==void 0)throw new Error("knodin fleet init accepts discovery roots, not --repo");let t=Ft(r,process.cwd());t.json||process.stderr.write("warning: `knodin fleet init` is deprecated; use `knodin repos init --linked-worktrees=skip|include` (alias retained for two minor releases)\n");let s=B(),a=H(t.roots[0]??process.cwd()),p=await ee(t.roots,{command:b,depth:t.depth,dryRun:t.dryRun,worktrees:t.worktrees,index:f=>s.index(f),status:f=>s.status(f),agents:Q(),indexMode:f=>te(a,f),isolatedInitialize:f=>Ee({repository:f,command:b})});await s.close(),process.stdout.write(t.json?`${JSON.stringify(p)}
-`:pe(p)),process.exitCode=p.exitCode;return}if(n==="repos"){if(g!==void 0)throw new Error("knodin repos accepts discovery roots, not --repo");let t=Mt(r,process.cwd());if(t.command==="discover"){let m=await ue(t.roots,{depth:t.depth,linkedWorktrees:t.linkedWorktrees}),y=B(),v=H(t.roots[0]??process.cwd()),R=[],E=t.signals?m.repositories.slice(0,Pt(t)):m.repositories;for(let N of E){let M=await Z(N,{status:async Y=>A(Y,await y.status(Y,{audit:"cached"})),systemMemberships:Y=>X(v,Y)});R.push(qt(M,t.signals,t.signals?await Lt(N.path):{}))}await y.close();let I={schemaVersion:1,command:"discover",linkedWorktrees:t.linkedWorktrees,...m,repositories:R},q=t.signals?le(I,"repositories:discover",{bytes:t.byteBudget,tokens:t.tokenBudget,items:t.itemBudget},{bytes:65536,tokens:16384,items:100}):I;process.stdout.write(`${JSON.stringify(q,null,t.json?0:2)}
-`),process.exitCode=m.issues.length>0?1:0;return}if(t.command==="init"){let m=H(t.roots[0]??process.cwd());if(t.dryRun){let N=await ee(t.roots,{command:b,depth:t.depth,dryRun:!0,worktrees:t.linkedWorktrees,manifestPath:t.manifestPath,include:t.include,exclude:t.exclude,index:async()=>{},status:async()=>{throw new Error("dry-run must not inspect graph databases")},agents:Q(),indexMode:U=>te(m,U)}),M=N.results.reduce((U,Le)=>{let qe=Le.plannedStatus??Le.status;return U[qe]=(U[qe]??0)+1,U},{}),Y={schemaVersion:1,command:"init",dryRun:!0,graphDatabasesOpened:0,modelsLoaded:0,selectedRepositories:N.results.filter(({message:U})=>U.startsWith("dry-run:")).length,planned:M,...N,repositories:[]};process.stdout.write(t.json?`${JSON.stringify(Y)}
-`:pe(N)),process.exitCode=N.exitCode;return}let y=B(),v=await ee(t.roots,{command:b,depth:t.depth,dryRun:!1,worktrees:t.linkedWorktrees,manifestPath:t.manifestPath,include:t.include,exclude:t.exclude,index:N=>y.index(N),status:N=>y.status(N),agents:Q(),indexMode:N=>te(m,N),isolatedInitialize:N=>Ee({repository:N,command:b})}),R=await ue(t.roots,{depth:t.depth,linkedWorktrees:t.linkedWorktrees}),E=[],I=new Set(v.results.map(({repository:N})=>N));for(let N of R.repositories.filter(({path:M})=>I.has(M)))E.push(await Z(N,{status:async M=>A(M,await y.status(M,{audit:"cached"})),systemMemberships:M=>X(m,M)}));await y.close();let q={schemaVersion:1,command:"init",...v,repositories:E};process.stdout.write(t.json?`${JSON.stringify(q)}
-`:pe(v)),process.exitCode=v.exitCode;return}if(t.command==="search"){let m=B(),y=H(t.roots[0]??process.cwd()),v=await jt(t.roots,t.query??"",{depth:t.depth,linkedWorktrees:t.linkedWorktrees,include:t.include,exclude:t.exclude,allowPartial:t.allowPartial,itemBudget:t.itemBudget,byteBudget:t.byteBudget,tokenBudget:t.tokenBudget,cursor:t.cursor,status:async R=>A(R,await m.status(R,{audit:"cached"})),search:(R,E,I,q)=>m.search(R,E,I,{offset:q,includeSource:!0,federate:!1}),systemMemberships:R=>X(y,R)});await m.close(),process.stdout.write(`${JSON.stringify(v,null,t.json?0:2)}
-`),process.exitCode=v.status==="unavailable"?1:0;return}let s=await ue(t.roots,{depth:t.depth,linkedWorktrees:t.linkedWorktrees}),a=B(),p=H(t.roots[0]??process.cwd()),f=[];for(let m of s.repositories)try{if(t.command==="doctor"){let y=A(m.path,await a.status(m.path,{audit:"deep"})),v=await Z(m,{status:async()=>y,systemMemberships:R=>X(p,R)});f.push({...v,diagnosis:await ae(m.path,{currentVersion:F,runtimeCommand:b,graph:y})})}else f.push(await Z(m,{status:async y=>A(y,await a.status(y,{audit:"cached"})),systemMemberships:y=>X(p,y)}))}catch(y){f.push({path:m.path,status:"unknown",error:y instanceof Error?y.message:String(y)})}await a.close();let h={schemaVersion:1,command:t.command,linkedWorktrees:t.linkedWorktrees,repositories:f,issues:s.issues,emptyRoots:s.emptyRoots,staleLinkedWorktrees:s.staleLinkedWorktrees};process.stdout.write(`${JSON.stringify(h,null,t.json?0:2)}
-`),process.exitCode=s.issues.length>0||f.some(m=>"health"in m&&m.health!=="healthy"||"status"in m&&m.status==="unknown")?1:0;return}if(n==="docs"){if(g!==void 0)throw new Error("knodin docs does not accept --repo");let[t,...s]=r;if(s.length>0)throw new Error(`knodin docs: unknown argument ${s[0]}`);if(!t||t==="list"){process.stdout.write(`${it().join(`
-`)}
-`);return}let a=st(t);if(!a)throw new Error(`knodin docs: unknown topic ${t}`);process.stdout.write(a.endsWith(`
-`)?a:`${a}
-`);return}if(n==="update"){if(g!==void 0)throw new Error("knodin update does not accept --repo");let[t,...s]=d;if(!t||!["status","check","explain","apply","rollback"].includes(t))throw new Error("knodin update requires status, check, explain, apply, or rollback");if(s.length>0)throw new Error(`knodin update ${t}: unknown argument ${s[0]}`);let a=re(b),p=async y=>{let[v,...R]=y;if(!v)return{status:1,stdout:"",stderr:"missing manager command"};let E=Ie(v,R,{encoding:"utf-8",timeout:12e4,maxBuffer:4*1024*1024,stdio:["ignore","pipe","pipe"]});return{status:E.status,stdout:E.stdout??"",stderr:E.stderr??E.error?.message??""}},f=async()=>{let[y,...v]=b;if(!y)return!1;let R=Ie(y,[...v,"--version"],{encoding:"utf-8",timeout:1e4,stdio:["ignore","pipe","pipe"]});return R.status===0&&/^\d+\.\d+\.\d+/.test(R.stdout.trim())},h={currentVersion:F,installMethod:a,env:process.env,runManager:p,healthCheck:f},m;if(t==="status")m=ke(h);else if(t==="check")try{m=await be(h)}finally{process.env.KNODIN_UPDATE_BACKGROUND==="1"&&ct()}else t==="explain"?m=dt(h):t==="apply"?m=await lt(h):m=await ut(h);process.stdout.write($?`${JSON.stringify(m)}
-`:oe("update",m));return}if(process.stdout.isTTY&&at({currentVersion:F,installMethod:re(b),env:process.env})){let[t,...s]=b;t&&en(t,[...s,"update","check","--json"],{detached:!0,stdio:"ignore",env:{...process.env,KNODIN_UPDATE_BACKGROUND:"1"}}).unref()}let T=De(g,process.cwd());T.ok||(process.stderr.write(`${T.error}
-`),process.exit(1));let u=T.repo;if(n==="doctor"){let t=Ie(mt(),["rev-parse","--is-inside-work-tree"],{cwd:u,encoding:"utf-8",stdio:["ignore","pipe","ignore"]});if(t.status!==0||t.stdout.trim()!=="true"){let s={schemaVersion:1,status:"portfolio-root",path:u,graph:"not-inspected",warning:"Target is not a Git worktree; treating a portfolio parent as one repository would be misleading.",remediation:[`knodin repos doctor ${JSON.stringify(u)}`]};process.stdout.write($?`${JSON.stringify(s)}
-`:oe("doctor",s)),process.exitCode=1;return}}if(n==="compress"){let t=new Set(["--strategy","--adapter","--lines","--max-output-bytes","--context","--exit-code","--signal","--max-input-bytes","--start","--end","--limit","--offset"]),s=d.filter((y,v)=>!y.startsWith("--")&&!t.has(d[v-1])),a=(y,v,R,E)=>{let I=i(y),q=I===void 0?v:Number(I);if(!Number.isInteger(q)||q<R||q>E)throw new Error(`knodin compress: ${y} must be an integer from ${R} to ${E}`);return q},p=s[0]==="read"||s[0]==="diagnose"||s[0]==="delete"?s[0]:"create",f=p==="create"?void 0:s[1];if(p!=="create"&&!f)throw new Error(`knodin compress ${p} requires an artifact id`);let h,m=!1;if(p==="diagnose"){let y=B();try{let v=await V(u,R=>y.status(R,{audit:"cached"}));v.available?h=await ft(y,u,{artifactId:f??"",maxDiagnostics:a("--limit",10,1,50),diagnosticOffset:a("--offset",0,0,1e6),contextLines:a("--context",2,0,10),contextByteBudget:a("--max-output-bytes",16384,256,128*1024)}):(h=v,m=!0,process.exitCode=1)}finally{await y.close()}}else if(p==="read")h=je(u,f??"",{startLine:a("--start",1,1,Number.MAX_SAFE_INTEGER),endLine:i("--end")?a("--end",200,1,Number.MAX_SAFE_INTEGER):void 0,byteBudget:a("--max-output-bytes",16384,256,4*1024*1024),raw:d.includes("--raw")});else if(p==="delete")h=We(u,f??"");else{let y=i("--strategy")??"smart";if(!["smart","head-tail","errors-only"].includes(y))throw new Error("knodin compress: invalid --strategy");let v=i("--adapter")??"auto";if(!["auto","generic","vitest","jest","pytest","go-test","maven","gradle","dotnet","cargo"].includes(v))throw new Error("knodin compress: invalid --adapter");let R=a("--max-input-bytes",16*1024*1024,1,64*1024*1024),E={exitCode:i("--exit-code")?a("--exit-code",0,0,255):void 0,signal:i("--signal"),strategy:y,adapter:v,lineBudget:a("--lines",200,1,1e4),byteBudget:a("--max-output-bytes",16384,256,4*1024*1024),contextLines:a("--context",1,0,10),maxInputBytes:R,retain:!d.includes("--no-retain"),redactSecrets:!d.includes("--no-redact")},I=s[0]==="create"?s[1]??"-":s[0]??"-";h=I==="-"?Me(u,{...E,text:await qn(R)}):Fe(u,I,E)}p==="diagnose"&&(C.bytes!==void 0||C.tokens!==void 0||C.items!==void 0)&&(h=le(h,"compress:diagnose",C,{bytes:65536,tokens:16384,items:50})),$?process.stdout.write(`${JSON.stringify(h)}
-`):p==="diagnose"&&!m?process.stdout.write(Ln(h)):p==="diagnose"?process.stdout.write(oe("compress diagnose",h)):p==="read"?process.stdout.write(Pn(h)):p==="create"?process.stdout.write(An(h)):process.stdout.write(oe("compress delete",h));return}let x=B(),w,L,D=!1,_=0,Pe=!1,G=async t=>{let s=await V(u,async f=>A(f,await x.status(f,{audit:"cached"})));if(!s.available)return process.exitCode=1,s;let a=await t(),p=await V(u,async f=>A(f,await x.status(f,{audit:"cached"})));return p.available?ve(a,p.state,p.graph.freshness):(process.exitCode=1,p)};switch(n){case"doctor":{let t=i("--client");if(t!==void 0&&!["claude","codex","gemini","antigravity"].includes(t))throw new Error("knodin doctor: --client must be claude, codex, gemini, or antigravity");let s=d.filter((f,h)=>f!=="--client"&&d[h-1]!=="--client");if(s.length>0)throw new Error(`knodin doctor: unknown option ${s[0]}`);let a=await ae(u,{currentVersion:F,runtimeCommand:[...b,"serve"],graph:await x.status(u,{audit:"deep"}),client:t}),p=a.manager.name;a.update=await be({currentVersion:F,installMethod:["npm","mise","volta","nvm","fnm","asdf","homebrew"].includes(p??"")?p:"unknown",env:process.env}),w=a;break}case"system":{let t=d.includes("--allow-partial"),[s,a,...p]=d.filter(m=>m!=="--allow-partial");if(!s||!["list","show","validate","query"].includes(s))throw new Error("knodin system requires list, show, validate, or query");if(t&&s!=="query")throw new Error(`knodin system ${s}: --allow-partial applies only to query`);if(p.length>0)throw new Error(`knodin system ${s}: unknown argument ${p[0]}`);let f=await Se(H(u));if(s==="list"){if(a)throw new Error("knodin system list accepts no system id");w={schemaVersion:f.schemaVersion,systems:f.systems.map(({id:m,components:y})=>({id:m,componentCount:y.length}))};break}if(!a)throw new Error(`knodin system ${s} requires <system-id>`);let h=f.systems.find(({id:m})=>m===a);if(!h){w={status:"not-found",systemId:a,available:f.systems.map(({id:m})=>m)},process.exitCode=1;break}if(s==="show")w={status:"ok",system:h,repositories:f.repositories};else if(s==="validate"){let m=await Re(f,a,async y=>A(y,await x.status(y,{audit:"cached"})),u);w={systemId:a,...m},m.valid||(process.exitCode=1)}else{let m=await Re(f,a,async y=>A(y,await x.status(y,{audit:"cached"})),u);w=Wt(f,a,t,m),w.status==="unavailable"&&(process.exitCode=1)}break}case"hook-refresh":{let[t,s,a]=d,p;if(t==="commit")p={kind:t};else if(t==="checkout"&&s&&a)p={kind:t,before:s,after:a};else if(t==="merge"&&s&&a)p={kind:t,before:s,after:a};else if(t==="rewrite"&&s)p={kind:t,inputPath:s};else throw new Error("knodin hook-refresh: invalid lifecycle event");w={indexed:await kt(u,p,(h,m)=>x.index(h,m))};break}case"init":{let t=await Rn(r,u),s=t==="team"?[]:Xt(u),a=Zt(),p=xe(u);p.start(),a.start();let f;try{try{f=await $e(u,{command:b,index:(h,m)=>x.index(h,void 0,!1,m),scope:t,agents:s,onProgress:h=>{p.update(h),a.onProgress(h)}})}finally{await a.stop(),p.stop()}}catch(h){if(!(h instanceof yt))throw h;process.stderr.write(`${h.message}
-`),await x.close(),process.exitCode=1;return}w={status:"success",message:"knodin initialized successfully. Git lifecycle hooks configured.",paths:f};break}case"configure":{if(r.includes("--status")){w=ce(u)??{scope:"unconfigured",agents:[],warning:"AI agents are not configured by knodin. Run `knodin configure --scope personal`."};break}let t=we(r);if(!t)throw new Error("knodin configure: missing --scope");if(!Te.existsSync(W.join(u,".knodin","db.sqlite")))throw new Error("knodin configure changes agent integration only; this repository is not initialized. Run `knodin init` first.");let s=t==="team"?[]:Xt(u),a=await $e(u,{command:b,index:async()=>{},scope:t,agents:s,allowTrackedTransition:!0,auditConfigurationChanges:!0});w={status:"success",message:`knodin agent integration changed to ${t}.`,graphInitialization:"unchanged",nextAction:"run `knodin status` and reload the configured client",paths:a};break}case"index":{let t=He(d),s=ze(g,t,process.cwd());s.ok||(process.stderr.write(`${s.error}
-`),await x.close(),process.exit(1));let a=d.includes("--clean")||d.includes("--force"),p=i("--scip"),f=Zt("index"),h=xe(s.repo);h.start(),f.start();let m;try{m=await x.index(s.repo,s.files,a,{scip:p?{path:p}:void 0,onProgress:v=>{h.update(v),f.onProgress(v)}})}finally{await f.stop(),h.stop()}w=m;let y=Ge([...m.indexed,...m.unchanged],s.repo);y.ok||(process.stderr.write(`${y.error}
-`),await x.close(),process.exit(1)),m.verification.status!=="healthy"&&(process.stderr.write(Nn(m)),await x.close(),process.exit(1));break}case"status":{let t=async()=>({...A(u,await x.status(u,{audit:d.includes("--deep")?"deep":"cached"})),integration:ce(u),update:ke({currentVersion:F,installMethod:re(b),env:process.env})});if(d.includes("--watch")){let s=i("--interval"),a=s===void 0?1:Number(s);if(!Number.isFinite(a)||a<.1||a>60)throw new Error("knodin status: --interval must be between 0.1 and 60 seconds");let p=!0,f=()=>{p=!1};for(process.once("SIGINT",f),process.once("SIGTERM",f);p;){let h=await t();process.stdout.write(`${JSON.stringify({observedAt:new Date().toISOString(),...h})}
-`),await new Promise(m=>setTimeout(m,a*1e3))}process.removeListener("SIGINT",f),process.removeListener("SIGTERM",f),Pe=!0,w=null}else w=await t();break}case"wait":{if(!d.includes("--fresh"))throw new Error("knodin wait requires --fresh");let t=i("--timeout"),s=t===void 0?30:Number(t);if(!Number.isFinite(s)||s<0||s>300)throw new Error("knodin wait: --timeout must be between 0 and 300 seconds");w=await Ht(x,u,Math.round(s*1e3)),w.status!=="fresh"&&(process.exitCode=1);break}case"repair":{let t=_t(d);if(t.plan){w=It(await x.status(u,{audit:"deep"})),L=t.output,D=!0;break}let s=Nt(t,process.env,process.stderr.isTTY),a=s==="tty"?tn("repair-progress-worker",{type:"start"}):(()=>{let h=Tt({mode:s,intervalMs:t.progressIntervalMs,stdout:process.stdout,stderr:process.stderr});return{start:()=>h.start(),onProgress:m=>h.onProgress(m),stop:async()=>h.stop()}})(),p=new AbortController,f=()=>p.abort();process.once("SIGINT",f),a.start();try{w=rt(u,await x.repair(u,{signal:p.signal,onProgress:h=>a.onProgress(h)}))}finally{process.removeListener("SIGINT",f),await a.stop()}L=t.output,w.cancelled&&(_=130);break}case"refresh-artifacts":{let t=d[0]??"code-change";t!=="checkout"&&t!=="merge"&&t!=="code-change"&&(process.stderr.write(`knodin refresh-artifacts accepts checkout, merge, or code-change
-`),process.exit(1));let s=Gt(u,t);Ut(u,s),w=s;break}case"explain":{let t=d[0];t||(process.stderr.write(`knodin explain requires a <symbol>
-`),process.exit(1)),w=await G(async()=>{let s=await x.explain(t,u,d[1]==="minimal"?"minimal":"standard",O);return d[1]==="source"&&!s.ambiguity?{mode:"source",identity:s.identity,symbol:s.symbol,source:s.source,staleness:s.staleness}:s});break}case"review":{let t=Ue(d);w=await G(()=>x.review(t.base,u,t.detailLevel,t.options));break}case"map":w=await G(()=>x.map(u,d.includes("--standard")?"standard":"minimal",{topN:i("--top")?Number(i("--top")):void 0,sort:i("--sort"),relationKinds:i("--relations")?.split(",").filter(Boolean)}));break;case"wiki":{let t=await V(u,async p=>A(p,await x.status(p,{audit:"cached"})));if(!t.available){w=t,process.exitCode=1;break}let s=d.includes("--force"),a=await x.wiki(u,s);await x.close(),process.stdout.write(`wrote ${a.written.length} pages, skipped ${a.skipped.length}
-`),process.exitCode=0;return}case"visualize":{let t=d.find((a,p)=>!a.startsWith("--")&&!d[p-1]?.startsWith("--")),s=i("--output");if(!t)throw new Error("knodin visualize requires an <entry> selector");if(!s)throw new Error("knodin visualize requires --output <path.html>");w=await G(()=>Qt(x,u,{entry:t,outputPath:s,depth:i("--depth")?Number(i("--depth")):void 0,byteBudget:i("--max-bytes")?Number(i("--max-bytes")):void 0,selector:{identity:O.identity,file:O.file,kind:O.kind}}));break}case"search":{let t=d[0];t||(process.stderr.write(`knodin search requires a <query>
-`),process.exit(1));let s=d[1]&&!d[1].startsWith("--")?d[1]:void 0,a=Number(i("--limit")??s??5);if(!Number.isInteger(a)||a<1)throw new Error("knodin search: limit must be a positive integer");w=await G(()=>x.search(t,u,a,{languages:i("--languages")?.split(",").filter(Boolean),extensions:i("--extensions")?.split(",").filter(Boolean),kinds:i("--kinds")?.split(",").filter(Boolean),path:i("--path"),testScope:d.includes("--tests-only")?"test":d.includes("--production-only")?"production":"all",includeSource:!d.includes("--no-source"),offset:i("--offset")?Number(i("--offset")):0}));break}case"pack":{let t=d[0],s=i("--diff-scope");if(s&&!["unstaged","staged","all","compare"].includes(s))throw new Error("knodin pack: invalid --diff-scope");if(t==="read"){if(!d[1])throw new Error("knodin pack read requires an artifact path");w=Je(u,d[1],Number(i("--start")??1),Number(i("--end")??200),Number(i("--bytes")??16384))}else if(t==="grep"){if(!d[1]||!d[2])throw new Error("knodin pack grep requires an artifact path and regex");w=Ye(u,d[1],d[2],i("--flags")??"",Number(i("--limit")??100))}else{let a={};for(let p of i("--policy")?.split(",")??[]){let[f,h]=p.split("=");if(!f||!["full","summary","structure-only"].includes(h))throw new Error("knodin pack: invalid --policy assignment");a[f]=h}w=Ke(u,{format:i("--format")??"markdown",include:i("--include")?.split(",").filter(Boolean),exclude:i("--exclude")?.split(",").filter(Boolean),policies:a,alreadyPresent:i("--already-present")?.split(",").filter(Boolean),chatFiles:i("--chat-files")?.split(",").filter(Boolean),lineNumbers:d.includes("--line-numbers"),includeTree:d.includes("--tree"),byteBudget:Number(i("--bytes")??65536),tokenBudget:Number(i("--tokens")??16384),outputPath:i("--output"),git:s||i("--log")?{diffScope:s,from:i("--from"),to:i("--to"),log:i("--log")?Number(i("--log")):void 0}:void 0})}break}case"evidence":{let t=d[0],s=d[1];if(!s||!["locate","outline","evidence","expand"].includes(t))throw new Error("knodin evidence requires locate|outline|evidence|expand <file>");w=Ot({repo:u,file:s,level:t,continuation:i("--continuation"),baselineHash:i("--baseline-hash"),baselineBytes:i("--baseline-bytes")?Number(i("--baseline-bytes")):void 0,startLine:i("--start")?Number(i("--start")):void 0,endLine:i("--end")?Number(i("--end")):void 0,byteLimit:C.bytes,tokenLimit:C.tokens,itemLimit:C.items});break}case"query":{let t=d[0],s=pt.includes(t),a=t==="architecture_overview"||t==="import_cycles"||d[1]?.startsWith("--")?"":d[1]??"";t||(process.stderr.write(`knodin query requires a <pattern> (lsp_diagnostics|lsp_definitions|lsp_declarations|lsp_implementations|callers_of|callees_of|imports_of|importers_of|import_cycles|file_summary|batch_outline|project_overview|shortest_path|inheritors_of|structural_implementations_of|tests_for|impact|dead_code|large_functions|large_files|rename_preview|flows|flow_of|stats|traverse|feature_path|flow_analysis|knowledge_gaps|surprising_connections|suggested_questions|architecture_overview|community|triggers_of|publishers_of|listeners_of|handlers_of|endpoints_for|consumers_of|children_of|federated_repos|mcp_tools|api_contract_mismatches)
-`),process.exit(1));let p=i("--direction");p&&!["upstream","downstream","both"].includes(p)&&(process.stderr.write(`knodin query: --direction must be upstream, downstream, or both
-`),process.exit(1));let f=i("--facets")?.split(",").filter(Boolean);f?.some(E=>!["packages","layers","boundaries","hotspots","entryPoints","languages"].includes(E))&&(process.stderr.write(`knodin query: --facets contains an unknown architecture facet
-`),process.exit(1)),!a&&!s&&(process.stderr.write(`knodin query ${t} requires a <target>
-`),process.exit(1));let h=t==="shortest_path"||t==="rename_preview"?d[2]:void 0;t==="rename_preview"&&!h&&(process.stderr.write(`knodin query rename_preview requires <old> and <new>
-`),process.exit(1));let m;if(t==="traverse"||t==="feature_path"||t==="impact"){let E=d.indexOf("--depth"),I=E>=0?d[E+1]:d[2];I!==void 0&&I!==""&&Number.isFinite(Number(I))&&(m=Number(I))}let y;t==="architecture_overview"&&d.includes("standard")&&(y="standard");let v=i("--limit");v!==void 0&&(!Number.isInteger(Number(v))||Number(v)<1)&&(process.stderr.write(`knodin query: --limit must be a positive integer
-`),process.exit(1));let R=t.startsWith("lsp_")?null:await V(u,async E=>A(E,await x.status(E,{audit:"cached"})));if(R&&!R.available){w=R,process.exitCode=1;break}if(w=await x.query(t,a,u,h,v?Number(v):void 0,m,y,O,t==="impact"?{mode:i("--impact-mode")==="file"?"file":"symbol",direction:["upstream","downstream","both"].includes(i("--direction")??"")?i("--direction"):void 0,relationKinds:i("--relations")?.split(",").map(E=>E.trim()).filter(Boolean),minConfidence:i("--min-confidence")?Number(i("--min-confidence")):void 0,includeTests:!d.includes("--exclude-tests"),includeDataFlow:d.includes("--data-flow")}:void 0,{minLines:i("--min-lines")?Number(i("--min-lines")):void 0,minComplexity:i("--min-complexity")?Number(i("--min-complexity")):void 0,kinds:i("--kinds")?.split(",").filter(Boolean),path:i("--path"),direction:t==="traverse"&&["upstream","downstream","both"].includes(i("--direction")??"")?i("--direction"):void 0,includeDataFlow:t==="traverse"?d.includes("--data-flow"):void 0,flowVariable:t==="flow_analysis"?i("--variable"):void 0,architectureFacets:f,topN:i("--top")?Number(i("--top")):void 0,sort:i("--sort"),relationKinds:t==="impact"?void 0:i("--relations")?.split(",").filter(Boolean),detailLevel:y}),t==="impact"||t==="dead_code"){let E=await Se(H(u));w=Bt(E,u,t,a,w)}if(R?.available){let E=await V(u,async I=>A(I,await x.status(I,{audit:"cached"})));if(!E.available){w=E,process.exitCode=1;break}w=ve(w,E.state,E.graph.freshness)}break}case"rename":{let t=d.filter(h=>!h.startsWith("--")),s=t[0],a=t[1],p=d.includes("--apply"),f=!d.includes("--no-verify");(!s||!a)&&(process.stderr.write(`knodin rename requires <old> and <new>
-`),process.exit(1)),w=await G(()=>x.rename(s,a,u,p,f,O));break}case"prs":{try{let t=d[0]==="audit"?d.slice(1):d,s=h=>{let m=t.indexOf(h);return m>=0?t[m+1]:void 0},a=s("--state"),p=s("--limit"),f=p===void 0?50:Number(p);if(!Number.isInteger(f)||f<1)throw new Error("knodin prs: --limit must be a positive integer");w=await Ct(u,x,{state:a,limit:f,branches:s("--branches"),range:s("--range"),base:s("--base"),head:s("--head"),expectedLogin:s("--expected-login")})}catch(t){await x.close(),process.stderr.write(`${t.message}
-`),process.exit(1)}break}case"worktrees":{let t=d[0]??"status";if(t==="status")w=await ht(u,s=>x.status(s,{audit:"cached"}));else if(t==="reconcile")w=gt(u);else if(t==="remove"){let s=d[1];if(!s)throw new Error("knodin worktrees remove requires <path>");w=wt(u,s,d.includes("--dry-run"))}else throw new Error(`knodin worktrees: unknown action ${t}`);break}case"telemetry":{let t=d[0],s=i("--retention-days"),a=s===void 0?30:Number(s);if(!Number.isInteger(a)||a<1||a>3650)throw new Error("knodin telemetry: --retention-days must be an integer from 1 to 3650");let p=i("--input");if(t==="status")w=Et(u,p,a);else if(t==="report")w=$t(u,de(u,p,a),i("--output"));else if(t==="export")w=Rt(u,de(u,p,a),i("--output"));else if(t==="clear")w=St(u,p);else throw new Error("knodin telemetry requires status, report, export, or clear");break}case"diagnostics":{let[t,s]=c.positionals,a=i("--retention-days"),p=i("--since"),f=i("--output"),h=a===void 0?14:Number(a);if(!Number.isInteger(h)||h<1||h>365)throw new Error("knodin diagnostics: --retention-days must be an integer from 1 to 365");if(s&&t!=="inspect")throw new Error(`knodin diagnostics ${t}: unexpected bundle argument`);if(a!==void 0&&t!=="enable")throw new Error(`knodin diagnostics ${t}: --retention-days applies only to enable`);if(p!==void 0&&t!=="collect")throw new Error(`knodin diagnostics ${t}: --since applies only to collect`);if(f!==void 0&&t!=="collect")throw new Error(`knodin diagnostics ${t}: --output applies only to collect`);if(t==="enable")w=Qe(u,h);else if(t==="status")w=Ze(u);else if(t==="disable")w=Xe(u);else if(t==="clear")w=tt(u);else if(t==="inspect"){if(!s)throw new Error("knodin diagnostics inspect requires <bundle>");w=ot(u,s)}else if(t==="collect"){let m=p??"24h",y=/^(\d+)(h|d)$/.exec(m);if(!y)throw new Error("knodin diagnostics collect: --since must be hours or days, such as 24h or 7d");let v=Number(y[1])*(y[2]==="d"?24:1),R=A(u,await x.status(u,{audit:"deep"})),E=await ae(u,{currentVersion:F,runtimeCommand:[...b,"serve"],graph:R});w=nt(u,{sinceHours:v,outputPath:f,doctor:E,graph:R,telemetry:de(u,void 0,Math.max(1,Math.ceil(v/24))),knodinVersion:F})}else throw new Error("knodin diagnostics requires enable, status, collect, inspect, clear, or disable");break}case"context":{let t=d[0];t||(process.stderr.write(`knodin context requires a "<task>" description
-`),process.exit(1)),w=await G(()=>Ve(x,t,u,d[1]));break}default:process.stderr.write(`unknown command: ${n}
-
-${ge([],process.stderr.isTTY?process.stderr.columns:void 0)}`),process.exit(1)}if(await x.close(),Pe)return;let z=le(w,n,C,{bytes:65536,tokens:16384,items:100}),J=Math.max(Number(process.exitCode??0),_);if(n==="init"&&!$){process.stdout.write(Sn(z)),process.exitCode=J;return}if(n==="configure"&&!$&&!r.includes("--status")){process.stdout.write(On(z));return}if(n==="configure"&&!$&&r.includes("--status")){process.stdout.write(Cn(z));return}if(n==="repair"&&L==="human"&&!D){process.stdout.write(_n(z)),process.exitCode=J;return}if(n==="index"&&!$){process.stdout.write(In(w)),process.exitCode=J;return}if(n==="status"&&!$){process.stdout.write(Tn(z)),process.exitCode=J;return}if(!$&&L!=="jsonl"){process.stdout.write(oe(n,z)),process.exitCode=J;return}process.stdout.write(L==="jsonl"?At("result",z):`${JSON.stringify(z)}
-`),process.exitCode=J}jn().catch(e=>{let o=process.argv.slice(2),n=o.indexOf("--repo"),r=o.find($=>$.startsWith("--repo=")),c=n>=0&&o[n+1]?o[n+1]:r?r.slice(7):process.cwd(),l=o.find(($,d)=>$.startsWith("-")?!1:!(d>0&&o[d-1]==="--repo")&&$!==c),g=et(c,{surface:"cli",operation:l&&new Set(["init","configure","index","doctor","status","wait","repair","serve","context","explain","review","map","search","query","rename","wiki","visualize","pack","compress","prs","worktrees","telemetry","diagnostics","system","repos","update"]).has(l)?l:"unknown",phase:"dispatch",error:e}),b=g.recorded?` [diagnostic ${g.correlationId}]`:"";console.error(`${e instanceof Error?e.message:String(e)}${b}`),process.exit(1)});
+/**
+ * `knodin` CLI — the daily driver.
+ *
+ *   knodin explain <symbol> [minimal]   edit-ready source + direct call paths + blast radius
+ *   knodin review [base]      risk-scored context with explicit git diff scopes
+ *   knodin map                subsystems + confidence-tagged edges
+ *   knodin wiki [--force]     write .knodin/wiki/ (index.md + per-community pages)
+ *   knodin serve              run the MCP server on stdio
+ *
+ * The same engine backs both the CLI and the MCP server, so any assistant and
+ * a human at a terminal see identical results.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { detectSupportedAgents, parseInitScope, } from "../src/agent-integration.js";
+import { refreshExternalGraphArtifacts, writeArtifactRefreshRecord, } from "../src/artifact-refresh.js";
+import { checkIndexed, extractPositionals, extractRepoFlag, parseReviewArgs, planIndex, resolveCliRuntimeCommand, resolveRepo, } from "../src/cli-args.js";
+import { helpCommandPath, parseCliInvocation, renderCliHelp } from "../src/cli-model.js";
+import { buildKnodinContext } from "../src/context.js";
+import { exportContext, grepPackedArtifact, readPackedArtifact } from "../src/context-export.js";
+import { clearDiagnostics, collectDiagnostics, diagnosticsStatus, disableDiagnostics, enableDiagnostics, inspectDiagnosticsBundle, persistDiagnosticsPreview, recordDiagnosticFailure, } from "../src/diagnostics.js";
+import { getDocSection, listDocTopics } from "../src/docs-sections.js";
+import { diagnoseInstallation } from "../src/doctor.js";
+import { createEngine, REPO_WIDE_QUERY_PATTERNS, } from "../src/engine/index.js";
+import { resolveDbPath } from "../src/engine/state-paths.js";
+import { diagnoseFailure, } from "../src/failure-diagnosis.js";
+import { gitExecutable } from "../src/git-executable.js";
+import { decorateGraphQueryResult, inspectGraphQueryHealth } from "../src/graph-query-health.js";
+import { createIndexActivityReporter } from "../src/index-activity.js";
+import { detectTrackedTeamIntegration, InitializationHealthError, initializeRepository, inspectRepositoryIntegrationStatus, readRepositoryIntegrationConfig, refreshFromGitEvent, } from "../src/init.js";
+import { createInitProgressRenderer } from "../src/init-progress.js";
+import { attachLifecycleHealth, attachRepairLifecycle } from "../src/lifecycle-health.js";
+import { addMirror, listMirrors, refreshMirror, removeMirror } from "../src/mirror.js";
+import { compressOutput, compressOutputFile, deleteOutputArtifact, readOutputArtifact, } from "../src/output-compression.js";
+import { clearTelemetry, exportTelemetry, readTelemetryRecords, telemetryStatus, writeTelemetryReport, } from "../src/output-telemetry.js";
+import { auditPullRequests } from "../src/pr-triage.js";
+import { deliverProgressiveEvidence, } from "../src/progressive-evidence.js";
+import { createRepairPlan, createRepairProgressRenderer, parseRepairCliArgs, resolveRepairProgressMode, serializeRepairJsonlRecord, } from "../src/repair-progress.js";
+import { runRepositoryInitializationProcess } from "../src/repository-init-process.js";
+import { detectRepositorySignals, discoverRepositories, formatRepositoryHuman, initializeRepositories, inventoryRepository, parseFleetInitArgs, parseRepositoryCommandArgs, repositorySignalInspectionLimit, searchRepositories, withRepositorySignals, } from "../src/repository-management.js";
+import { applyResponseBudget } from "../src/response-budget.js";
+import { configuredRepositoryInitMemoryLimitBytes, enrichSystemRelationships, incorporateSystemQueryEvidence, indexModeForPath, loadSystemConfiguration, queryConfiguredSystem, systemMembershipsForPath, validateSystemHealth, } from "../src/system-config.js";
+import { applyTrustedUpdate, checkTrustedUpdate, claimScheduledUpdateCheck, detectUpdateInstallMethod, explainTrustedUpdate, releaseScheduledUpdateCheck, rollbackTrustedUpdate, trustedUpdateStatus, } from "../src/update-policy.js";
+import { KNODIN_VERSION } from "../src/version.js";
+import { writeVisualization, } from "../src/visualization.js";
+import { waitForFresh } from "../src/wait-for-fresh.js";
+import { inspectWorktrees, reconcileWorktrees, removeManagedWorktree, } from "../src/worktree-lifecycle.js";
+function explicitScope(args) {
+    const index = args.indexOf("--scope");
+    if (index >= 0) {
+        const value = args[index + 1];
+        if (!value)
+            throw new Error("knodin: --scope requires a value");
+        return parseInitScope(value);
+    }
+    const equals = args.find((argument) => argument.startsWith("--scope="));
+    return equals ? parseInitScope(equals.slice("--scope=".length)) : null;
+}
+async function chooseInitScope(args, repo) {
+    const selected = explicitScope(args);
+    if (selected)
+        return selected;
+    if (detectTrackedTeamIntegration(repo)) {
+        process.stderr.write("[init:scope] Detected tracked knodin team integration; preserving team scope\n");
+        return "team";
+    }
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        return "personal";
+    const prompt = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    try {
+        const answer = await prompt.question([
+            "How should knodin integrate with coding agents?",
+            "  1. Personal (recommended) — all detected agents; Git stays clean",
+            "  2. Team — create commit-ready shared configuration",
+            "  3. CLI-only — agents will not discover or invoke knodin automatically",
+            "Select [1]: ",
+        ].join("\n"));
+        if (!answer.trim() || answer.trim() === "1")
+            return "personal";
+        if (answer.trim() === "2")
+            return "team";
+        if (answer.trim() === "3") {
+            const confirmation = await prompt.question("CLI-only requires manual knodin commands. Continue? [y/N] ");
+            if (!/^y(?:es)?$/i.test(confirmation.trim()))
+                throw new Error("knodin init: CLI-only selection cancelled");
+            return "cli-only";
+        }
+        return parseInitScope(answer.trim());
+    }
+    finally {
+        prompt.close();
+    }
+}
+function integrationAgents(repo) {
+    const previous = readRepositoryIntegrationConfig(repo)?.agents ?? [];
+    const repositoryDetected = inspectRepositoryIntegrationStatus(repo)?.agents ?? [];
+    return [...new Set([...detectSupportedAgents(), ...previous, ...repositoryDetected])];
+}
+function formatInitHuman(result) {
+    let agents = `${result.paths.scope} — no supported coding agents detected`;
+    if (result.paths.scope === "cli-only")
+        agents = "CLI-only — AI agents are not configured to discover knodin";
+    else if (result.paths.agentIntegration.configured.length > 0)
+        agents = `${result.paths.scope} — ${result.paths.agentIntegration.configured.join(", ")}`;
+    const failures = result.paths.agentIntegration.failed
+        .map(({ agent, message }) => `\nAgent warning (${agent}): ${message}`)
+        .join("");
+    const refresh = result.paths.lifecycleRefresh.state === "fresh"
+        ? "fresh"
+        : `still running (${result.paths.lifecycleRefresh.queuedEvents} queued event(s)); run \`knodin wait --fresh\``;
+    return `${result.message}\nGraph: ${result.paths.database}\nGit refresh: ${result.paths.gitHooks.length} lifecycle hooks installed; ${refresh}\nAgent integration: ${agents}${failures}\nBackground indexer: ${result.paths.backgroundIndexer}\n`;
+}
+function formatConfigureStatusHuman(result) {
+    if (result.scope === "unconfigured")
+        return "Agent integration: unconfigured.\nWarning: AI agents will not discover or invoke knodin automatically. Run `knodin configure --scope personal`.\n";
+    if (result.scope === "cli-only")
+        return "Agent integration: CLI-only.\nWarning: AI agents will not discover or invoke knodin automatically. Run `knodin configure --scope personal` or `--scope team` to enable them.\n";
+    if (result.scope === "repository-detected")
+        return `Agent integration: repository-detected${result.agents.length > 0 ? ` (${result.agents.join(", ")})` : ""}.\nLocal scope receipt: missing; managed repository integration is present.\n`;
+    return `Agent integration: ${result.scope}${result.agents.length > 0 ? ` (${result.agents.join(", ")})` : ""}.\n`;
+}
+function formatConfigureHuman(result) {
+    let configured = "none detected";
+    if (result.paths.agentIntegration.configured.length > 0) {
+        configured = result.paths.agentIntegration.configured.join(", ");
+    }
+    else if (result.paths.scope === "cli-only") {
+        configured = "none (CLI-only)";
+    }
+    const failures = result.paths.agentIntegration.failed
+        .map(({ agent, message }) => `\nAgent warning (${agent}): ${message}`)
+        .join("");
+    const refresh = result.paths.lifecycleRefresh.state === "fresh"
+        ? "fresh"
+        : `still running (${result.paths.lifecycleRefresh.queuedEvents} queued event(s))`;
+    const filesystemMutationLines = result.paths.filesystemChanges
+        .map(({ path: changedPath, action }) => `\nFilesystem ${action}: ${changedPath}`)
+        .join("");
+    const externalOutcomeLines = result.paths.externalConfigurationOutcomes
+        .map(({ system, state }) => `\nExternal configuration outcome: ${system} ${state} (external mutation not locally observable)`)
+        .join("");
+    return `${result.message}\nAgent integration: ${result.paths.scope} — ${configured}${failures}${filesystemMutationLines}${externalOutcomeLines}\nGraph initialization: unchanged\nLifecycle refresh: ${refresh}\nNext: ${result.nextAction}\n`;
+}
+function formatRepairHuman(result) {
+    const coverage = result.after.coverage;
+    if (result.cancelled) {
+        return `Repair paused: ${result.remaining ?? 0} file(s) remaining. Run \`knodin repair\` again to finish.\n`;
+    }
+    if (result.verified) {
+        if (result.lifecycle?.status === "degraded")
+            return `Repair verified: graph is healthy (${coverage.indexedFiles} indexed files, ${coverage.filesWithSymbols} files with symbols), but lifecycle routing is degraded. Run \`knodin init\`, then \`knodin status\`.\n`;
+        return `Repair verified: graph is healthy (${coverage.indexedFiles} indexed files, ${coverage.filesWithSymbols} files with symbols).\n`;
+    }
+    return `Repair finished with remaining issues. Run \`knodin status --deep\` for details.\n`;
+}
+function formatIndexHuman(result) {
+    if (result.indexed.length === 0 && result.unchanged.length > 0) {
+        const noun = result.unchanged.length === 1 ? "file" : "files";
+        return `Graph already current: ${result.unchanged.length.toLocaleString()} requested ${noun} needed no work; health verified.\n`;
+    }
+    const unchanged = result.unchanged.length > 0
+        ? `; ${result.unchanged.length.toLocaleString()} already current`
+        : "";
+    const noun = result.indexed.length === 1 ? "file" : "files";
+    return `Index complete: ${result.indexed.length.toLocaleString()} ${noun} indexed${unchanged}; graph health verified.\n`;
+}
+function formatIndexVerificationError(result) {
+    const firstIssue = result.verification.missing.files[0] ?? result.verification.missing.records[0];
+    const detail = firstIssue ? ` First issue: ${firstIssue}.` : "";
+    return `knodin index: requested work completed, but ${result.verification.issueCount.toLocaleString()} graph issue(s) remain.${detail} Run \`knodin repair\`.\n`;
+}
+/**
+ * The hooks/lifecycle line of `status`.
+ *
+ * A mirror has no hooks by design, so neither "installed" nor "degraded" is true
+ * of it: claiming they are "installed and executable" would describe a directory
+ * containing none, and reporting "degraded" would demand a `knodin init` that
+ * must never run there.
+ */
+function formatLifecycleLine(lifecycle, isMirror) {
+    if (!lifecycle)
+        return "";
+    if (isMirror)
+        return "Hooks: not applicable; a mirror is refreshed explicitly, not by Git events.\n";
+    if (lifecycle.status === "healthy")
+        return "Hooks: installed and executable.\n";
+    const issue = lifecycle.issues[0] ?? "refresh capability is not verified";
+    return `Lifecycle refresh: ${lifecycle.status}; ${issue}. Run \`knodin init\`.\n`;
+}
+/** Renders the top extensions of a tally as `.md 180, .yml 74, +3 more`. */
+function formatTally(counts, limit = 4) {
+    const entries = Object.entries(counts).sort((left, right) => right[1] - left[1]);
+    const shown = entries.slice(0, limit).map(([ext, count]) => `${ext} ${count}`);
+    const remaining = entries.length - shown.length;
+    if (remaining > 0)
+        shown.push(`+${remaining} more`);
+    return shown.join(", ");
+}
+/**
+ * One clause naming what the graph does not cover. Silence here would let a
+ * language gap read as an absence of facts, so this is appended to the coverage
+ * line whenever anything was skipped.
+ */
+function formatCoverageGaps(skipped) {
+    if (!skipped)
+        return "";
+    // A zero total is only reportable as "no gaps" when the tally was actually
+    // read. If it wasn't, staying silent would state full coverage on the
+    // strength of a measurement that never happened.
+    if (skipped.total === 0 && !skipped.unparsedUnknown)
+        return "";
+    const clauses = [];
+    const byExtension = formatTally(skipped.byExtension);
+    if (byExtension)
+        clauses.push(`not indexed: ${byExtension}`);
+    const unparsed = formatTally(skipped.unparsedByExtension);
+    if (unparsed)
+        clauses.push(`parsed but empty: ${unparsed}`);
+    if (skipped.unparsedUnknown)
+        clauses.push("parsed-but-empty tally unavailable — run a full index; this is a lower bound");
+    const count = skipped.unparsedUnknown ? `${skipped.total}+` : `${skipped.total}`;
+    return `. Not in graph: ${count} files (${clauses.join("; ")})`;
+}
+/**
+ * Recursive on-disk size of a directory.
+ *
+ * Reports unreadable entries rather than treating them as zero. The listing
+ * exists so acquired disk is auditable; a mirror that cannot be measured showing
+ * a confident `0 B` invites exactly the wrong conclusion — that it is empty and
+ * safe to remove — which is the same absence-as-fact error this whole feature
+ * is built to avoid.
+ */
+function directorySizeBytes(target) {
+    let bytes = 0;
+    let partial = false;
+    let entries;
+    try {
+        entries = fs.readdirSync(target, { withFileTypes: true });
+    }
+    catch {
+        return { bytes: 0, partial: true };
+    }
+    for (const entry of entries) {
+        const child = path.join(target, entry.name);
+        if (entry.isDirectory()) {
+            const nested = directorySizeBytes(child);
+            bytes += nested.bytes;
+            partial = partial || nested.partial;
+        }
+        else if (entry.isFile()) {
+            try {
+                bytes += fs.statSync(child).size;
+            }
+            catch {
+                partial = true;
+            }
+        }
+    }
+    return { bytes, partial };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KiB", "MiB", "GiB"];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value.toFixed(1)} ${units[unit]}`;
+}
+/**
+ * `knodin remote <add|list|remove|refresh>`.
+ *
+ * Mirrors are reported as snapshots, never as `fresh`: the clone is pinned to
+ * the commit it was fetched at, and nothing watches the remote for changes. Size
+ * and fetch time are shown for every mirror so acquired disk is auditable rather
+ * than silently accumulating.
+ */
+function writeMirrorListing() {
+    const mirrors = listMirrors();
+    if (mirrors.length === 0) {
+        process.stdout.write("No mirrors acquired. Add one with `knodin remote add <url>`.\n");
+        return;
+    }
+    let total = 0;
+    let anyPartial = false;
+    for (const mirror of mirrors) {
+        const size = directorySizeBytes(path.dirname(mirror.path));
+        total += size.bytes;
+        anyPartial = anyPartial || size.partial;
+        // "at least" rather than a bare figure when something was unreadable: a
+        // mirror reported as 0 B reads as empty, and the obvious next action on an
+        // empty mirror is to delete it.
+        const shown = size.partial ? `at least ${formatBytes(size.bytes)}` : formatBytes(size.bytes);
+        process.stdout.write(`${mirror.identity}  ${mirror.url}\n  snapshot ${mirror.sha.slice(0, 12)}, fetched ${mirror.fetchedAt}, ${shown}\n  ${mirror.path}\n`);
+    }
+    const totalShown = anyPartial ? `at least ${formatBytes(total)}` : formatBytes(total);
+    process.stdout.write(`${mirrors.length} mirror(s), ${totalShown} on disk. Remove one with \`knodin remote remove <identity>\`.\n`);
+}
+async function remoteAdd(url, options) {
+    const { record, alreadyPresent } = addMirror(url);
+    process.stdout.write(alreadyPresent
+        ? `Mirror already present: ${record.identity} (snapshot ${record.sha.slice(0, 12)}). Use \`knodin remote refresh ${record.identity}\` to update it.\n`
+        : `Acquired ${record.identity} at snapshot ${record.sha.slice(0, 12)} into ${record.path}\n`);
+    if (options.skipIndex || alreadyPresent)
+        return;
+    await indexMirror(record.path, options.deferSemantic);
+}
+async function remoteRefresh(identity, options) {
+    const record = refreshMirror(identity);
+    process.stdout.write(`Refreshed ${record.identity} to snapshot ${record.sha.slice(0, 12)} (${record.fetchedAt})\n`);
+    if (options.skipIndex)
+        return;
+    await indexMirror(record.path, options.deferSemantic);
+}
+async function runRemoteCommand(args) {
+    const [action, target] = args;
+    const options = {
+        skipIndex: args.includes("--no-index"),
+        deferSemantic: args.includes("--defer-semantic"),
+    };
+    if (action === "list")
+        return writeMirrorListing();
+    if (action === "remove") {
+        if (!target)
+            throw new Error("knodin remote remove requires an <identity>");
+        process.stdout.write(removeMirror(target) ? `Removed ${target}\n` : `No mirror named ${target}\n`);
+        return;
+    }
+    if (action === "add") {
+        if (!target)
+            throw new Error("knodin remote add requires a <url>");
+        return remoteAdd(target, options);
+    }
+    if (action === "refresh") {
+        if (!target)
+            throw new Error("knodin remote refresh requires an <identity>");
+        return remoteRefresh(target, options);
+    }
+    throw new Error("knodin remote <add|list|remove|refresh>");
+}
+/**
+ * Builds a mirror's graph structure-first, then fills embeddings.
+ *
+ * The embedding pass dominates indexing cost, so structural answers (`explain`,
+ * `callers_of`, blast radius) become available in a fraction of the total. The
+ * gap is reported rather than hidden: until embeddings land, `search` silently
+ * under-returns, so saying nothing here would hand back exactly the confident
+ * empty result this whole feature exists to avoid.
+ */
+async function indexMirror(source, deferSemantic) {
+    const engine = createEngine();
+    try {
+        await engine.index(source, undefined, true, { skipEmbeddings: true });
+        const structural = await engine.status(source, { audit: "deep" });
+        process.stdout.write(`Indexed ${structural.coverage.indexedFiles} file(s), ${structural.coverage.filesWithSymbols} with symbols${formatCoverageGaps(structural.coverage.skipped)}\n`);
+        process.stdout.write("Structural queries (explain, query, map) are ready now; semantic search is not.\n");
+        if (deferSemantic) {
+            process.stdout.write("Semantic coverage deferred. Run `knodin index --repo <mirror>` to build it; until then `search` will under-return.\n");
+            return;
+        }
+        process.stdout.write("Building semantic index...\n");
+        await engine.index(source, undefined, false);
+        const full = await engine.status(source, { audit: "deep" });
+        process.stdout.write(`Semantic coverage: ${full.semanticReadiness ?? "unknown"}\n`);
+    }
+    finally {
+        await engine.close();
+    }
+}
+function formatStatusHuman(result) {
+    // A mirror's `freshness` describes the graph against its local clone and can
+    // legitimately read `fresh`. Saying so without also saying the clone is a
+    // snapshot would imply knodin is tracking the remote, which it is not.
+    const mirrorNote = result.mirror
+        ? ` Mirror of ${result.mirror.url}: snapshot ${result.mirror.sha.slice(0, 12)}, fetched ${result.mirror.fetchedAt}; the remote is not watched.`
+        : "";
+    // Semantic search drops symbols that have no embedding, so an incomplete pass
+    // silently shortens results. Say so rather than let it read as "no matches".
+    const semanticNote = result.semanticReadiness && result.semanticReadiness !== "ready"
+        ? ` Semantic search coverage is ${result.semanticReadiness}: \`search\` will under-return until embedding completes (\`knodin index\`).`
+        : "";
+    const coverage = `${result.coverage.sourceFiles} source files, ${result.coverage.indexedFiles} indexed files, ${result.coverage.filesWithSymbols} files with symbols${formatCoverageGaps(result.coverage.skipped)}${mirrorNote}${semanticNote}`;
+    if (result.status === "indexing" && result.activity) {
+        const count = result.activity.phaseTotal === undefined
+            ? ""
+            : ` ${result.activity.phaseCompleted}/${result.activity.phaseTotal}`;
+        const elapsed = Math.max(0, Math.floor((Date.now() - Date.parse(result.activity.startedAt)) / 1_000));
+        return `Graph update in progress: ${result.activity.phase}${count} — ${result.activity.message} (${elapsed}s elapsed; ${coverage}).\n`;
+    }
+    const integration = result.integration;
+    const integrationAgents = integration && integration.agents.length > 0 ? ` (${integration.agents.join(", ")})` : "";
+    const integrationLine = integration
+        ? `Agent integration: ${integration.scope}${integrationAgents}.\n`
+        : "Agent integration: unconfigured. AI agents will not discover knodin automatically; run `knodin configure --scope personal`.\n";
+    // Replaces main's inline form: a mirror installs no hooks by design, so the
+    // inline version reported "needs repair — run knodin init" on every mirror
+    // status call, an instruction that must never be followed there.
+    const lifecycleLine = formatLifecycleLine(result.lifecycle, result.mirror !== undefined);
+    const head = (value) => value?.slice(0, 12) ?? "unknown";
+    const distance = result.freshness.commitDistance === null
+        ? ""
+        : ` by ${result.freshness.commitDistance.toLocaleString()} commit(s)`;
+    const freshnessLine = `Freshness: ${result.freshness.state}; indexed ${head(result.freshness.indexedHead)}, ` +
+        `current ${head(result.freshness.currentHead)} (${result.freshness.commitRelation}${distance}); ` +
+        `${result.freshness.workingTree.pendingPaths ?? "unknown"} pending path(s).\n` +
+        `Last successful refresh: ${result.freshness.lastSuccessfulRefresh ?? "never"}.\n`;
+    if (result.status === "healthy")
+        return `Graph content is healthy: ${coverage} (knodin ${result.version}; ${result.verification.mode}).\n${freshnessLine}${lifecycleLine}${integrationLine}`;
+    if (result.status === "stale")
+        return `Graph content is intact but evidence is stale (${coverage}).\n${freshnessLine}${lifecycleLine}${integrationLine}Run \`knodin wait --fresh\` or issue a graph query to reconcile bounded drift.\n`;
+    const outstanding = result.missing.files.length + result.missing.records.length;
+    const firstIssue = result.missing.files[0] ?? result.missing.records[0];
+    const detail = firstIssue ? ` First issue: ${firstIssue}.` : "";
+    const repairCommand = result.lifecycle?.status === "degraded" &&
+        result.missing.records.every((record) => result.lifecycle?.issues.includes(record))
+        ? "Run `knodin init`."
+        : "Run `knodin repair`.";
+    return `Graph or lifecycle needs repair: ${outstanding} issue(s) found (${coverage}).${detail} ${repairCommand}\n${lifecycleLine}${integrationLine}`;
+}
+function humanLabel(key) {
+    return key.replace(/([a-z])([A-Z])/g, "$1 $2");
+}
+/** Render bounded CLI data for a terminal without turning it back into JSON. */
+function formatHumanValue(value, indent = "", label) {
+    if (value === null || typeof value !== "object") {
+        const labelPrefix = label ? `${humanLabel(label)}: ` : "";
+        return [`${indent}${labelPrefix}${String(value)}`];
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return label ? [] : [`${indent}(none)`];
+        const lines = label ? [`${indent}${humanLabel(label)}:`] : [];
+        for (const item of value) {
+            if (item === null || typeof item !== "object")
+                lines.push(`${indent}  - ${String(item)}`);
+            else
+                lines.push(...formatHumanValue(item, `${indent}  - `));
+        }
+        return lines;
+    }
+    const entries = Object.entries(value).filter(([key]) => key !== "responseBudget");
+    const lines = label ? [`${indent}${humanLabel(label)}:`] : [];
+    for (const [key, child] of entries) {
+        if (child === null || typeof child !== "object") {
+            lines.push(`${indent}${label ? "  " : ""}${humanLabel(key)}: ${String(child)}`);
+        }
+        else
+            lines.push(...formatHumanValue(child, `${indent}${label ? "  " : ""}`, key));
+    }
+    return lines;
+}
+function formatGenericHuman(cmd, result) {
+    const lines = [`${humanLabel(cmd)}:`, ...formatHumanValue(result, "  ")];
+    return `${lines.join("\n")}\n`;
+}
+function formatCompressionHuman(result) {
+    const omitted = result.omittedRanges.reduce((total, range) => total + range.lineCount, 0);
+    let fidelity = `Compressed output; ${omitted} line(s) omitted.`;
+    if (result.status === "insufficient-budget")
+        fidelity = `INSUFFICIENT BUDGET: ${result.fidelity.unpreservedSignals.length} detected signal line(s) are available only through retained drill-down.`;
+    else if (result.complete)
+        fidelity = "Complete output; nothing omitted.";
+    const artifact = result.artifact.retained
+        ? ` Retained artifact: ${result.artifact.id} (${result.artifact.path}).`
+        : " Raw retention disabled; omitted regions cannot be retrieved.";
+    const content = result.content ? `${result.content}\n` : "";
+    return (`${content}---\n${fidelity} ` +
+        `${result.output.lines}/${result.input.lines} lines, ${result.output.bytes}/${result.input.bytes} bytes; ` +
+        `exit=${result.exit.code ?? "unknown"}, signal=${result.exit.signal ?? "none"}.${artifact}\n`);
+}
+function formatCompressionReadHuman(result) {
+    const content = result.content ? `${result.content}\n` : "";
+    const redactionStatus = result.raw
+        ? "UNREDACTED raw view"
+        : `${result.secretRedactions} secret(s) redacted`;
+    return (`${content}---\nArtifact ${result.artifactId}, lines ${result.range.startLine}-${result.range.endLine}` +
+        ` of ${result.range.totalLines}; ${result.bytes}/${result.byteBudget} bytes; ` +
+        `${redactionStatus}.\n`);
+}
+function formatFailureRelations(label, relations) {
+    if (relations.length === 0)
+        return `${label}: none`;
+    const formatted = relations.map(({ symbol, file, line }) => {
+        const location = file ? ` (${file}:${line ?? "?"})` : "";
+        return `${symbol}${location}`;
+    });
+    return `${label}: ${formatted.join(", ")}`;
+}
+function formatFailureDiagnosisHuman(result) {
+    const lines = [
+        `Failure diagnosis: ${result.status}; ${result.diagnostics.length} resolved, ${result.unresolved.length} unresolved.`,
+        `Freshness: ${result.freshness.state}; indexed=${result.freshness.indexedHead ?? "unknown"}; current=${result.freshness.currentHead ?? "unknown"}.`,
+    ];
+    for (const diagnostic of result.diagnostics) {
+        const location = `${diagnostic.file}:${diagnostic.reference.line ?? "?"}`;
+        const identity = diagnostic.owner?.identity ? ` [${diagnostic.owner.identity}]` : "";
+        const owner = `${diagnostic.owner?.symbol ?? "no owning symbol"}${identity}`;
+        const packageDescription = diagnostic.package
+            ? `${diagnostic.package.name ?? "unnamed"} (${diagnostic.package.kind}, ${diagnostic.package.manifest})`
+            : "none";
+        lines.push("", `${location} -> ${owner}`, `Package: ${packageDescription}`, formatFailureRelations("Tests", diagnostic.tests), formatFailureRelations("Upstream", diagnostic.upstream), formatFailureRelations("Downstream", diagnostic.downstream));
+        const snippet = result.contextBundle.snippets.find(({ file }) => file === diagnostic.file);
+        if (snippet)
+            lines.push(snippet.content);
+    }
+    for (const unresolved of result.unresolved) {
+        const candidates = unresolved.candidates ? ` (${unresolved.candidates.join(", ")})` : "";
+        lines.push("", `Unresolved ${unresolved.reference.path}: ${unresolved.reason}${candidates}`);
+    }
+    lines.push("", ...result.limitations.map((limitation) => `Limitation: ${limitation}`));
+    return `${lines.join("\n")}\n`;
+}
+async function readBoundedStdin(maxBytes) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        bytes += buffer.byteLength;
+        if (bytes > maxBytes)
+            throw new Error(`knodin compress: input exceeded bounded retention limit of ${maxBytes} bytes`);
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+const CLEAR_TERMINAL_LINE = "\r\x1b[2K";
+const PROGRESS_WORKER_CLOSE_TIMEOUT_MS = 2_000;
+/** Resolve true when `closed` settles first, false when the deadline wins. */
+function raceWorkerClose(closed, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (closedCleanly) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(closedCleanly);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref();
+        void closed.then(() => finish(true));
+    });
+}
+function createProgressWorkerRenderer(workerName, startMessage) {
+    const extension = fileURLToPath(import.meta.url).endsWith(".ts") ? ".ts" : ".js";
+    const workerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../src/${workerName}${extension}`);
+    const workerArgs = extension === ".ts" && path.basename(process.execPath).startsWith("node")
+        ? [...process.execArgv, workerPath]
+        : [workerPath];
+    const worker = spawn(process.execPath, workerArgs, {
+        stdio: ["pipe", "ignore", "inherit"],
+        env: { ...process.env, KNODIN_FORCE_PROGRESS_TTY: "1" },
+    });
+    let failed = false;
+    const closed = new Promise((resolve) => {
+        worker.once("close", () => resolve());
+        worker.once("error", () => resolve());
+    });
+    worker.once("error", () => {
+        failed = true;
+    });
+    worker.stdin.once("error", () => {
+        failed = true;
+    });
+    const send = (message) => {
+        if (failed || worker.stdin.destroyed)
+            return;
+        try {
+            worker.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+        catch {
+            failed = true;
+        }
+    };
+    return {
+        start: () => send(startMessage),
+        onProgress: (event) => send({ type: "progress", event }),
+        stop: async () => {
+            send({ type: "stop" });
+            worker.stdin.end();
+            const waitForClose = (timeoutMs) => raceWorkerClose(closed, timeoutMs);
+            if (!(await waitForClose(PROGRESS_WORKER_CLOSE_TIMEOUT_MS))) {
+                // Rendering is observational. A wedged terminal renderer must never
+                // hold graph work or its completion summary hostage.
+                worker.kill("SIGKILL");
+                if (!(await waitForClose(500)))
+                    worker.unref();
+            }
+            process.stderr.write(CLEAR_TERMINAL_LINE);
+        },
+    };
+}
+function createInitRenderer(operation = "init") {
+    if (process.stderr.isTTY !== true) {
+        const renderer = createInitProgressRenderer({
+            stderr: process.stderr,
+            operation,
+        });
+        return {
+            start: () => renderer.start(),
+            onProgress: (event) => renderer.onProgress(event),
+            stop: async () => renderer.stop(),
+        };
+    }
+    return createProgressWorkerRenderer("init-progress-worker", {
+        type: "start",
+        operation,
+    });
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === "__repository-init-worker") {
+        if (argv.length !== 2 || !path.isAbsolute(argv[1]))
+            throw new Error("knodin internal repository init worker requires one absolute path");
+        const repository = await fs.promises.realpath(argv[1]);
+        const interval = setInterval(() => {
+            process.send?.({ type: "rss", rssBytes: process.memoryUsage().rss });
+        }, 50);
+        interval.unref();
+        process.send?.({ type: "rss", rssBytes: process.memoryUsage().rss });
+        const engine = createEngine();
+        try {
+            const systemConfig = loadSystemConfiguration(repository);
+            const summary = await initializeRepositories([repository], {
+                // A portfolio worker owns exactly one already-discovered worktree.
+                // Do not recursively initialize nested repositories inside the same
+                // process, which would evade the per-repository memory boundary.
+                depth: 0,
+                include: [repository],
+                command: resolveCliRuntimeCommand(process),
+                index: (target) => engine.index(target),
+                status: (target) => engine.status(target),
+                agents: detectSupportedAgents(),
+                indexMode: (target) => indexModeForPath(systemConfig, target),
+            });
+            const result = summary.results.find(({ repository: target }) => target === repository);
+            if (!result)
+                throw new Error("repository init worker produced no repository result");
+            process.send?.({ type: "rss", rssBytes: process.memoryUsage().rss });
+            process.send?.({ type: "result", result });
+            if (result.status === "failed")
+                process.exitCode = 1;
+        }
+        finally {
+            clearInterval(interval);
+            await engine.close();
+        }
+        return;
+    }
+    // Keep a normalized argv for compatibility dispatch while Commander remains
+    // the authoritative grammar, option parser, validator, and help source.
+    const { rest: cleaned } = extractRepoFlag(argv);
+    const [cmd, ...rawRest] = cleaned;
+    if (!cmd || cmd === "-h" || cmd === "--help") {
+        process.stdout.write(renderCliHelp([], process.stdout.isTTY ? process.stdout.columns : undefined));
+        return;
+    }
+    if (cmd === "-v" || cmd === "--version" || cmd === "version") {
+        process.stdout.write(`${KNODIN_VERSION}\n`);
+        return;
+    }
+    if (argv.some((argument) => argument === "-h" || argument === "--help")) {
+        process.stdout.write(renderCliHelp(helpCommandPath(argv), process.stdout.isTTY ? process.stdout.columns : undefined));
+        return;
+    }
+    const invocation = parseCliInvocation(argv);
+    const optionKey = (flag) => flag.slice(2).replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+    const selectorValue = (flag) => {
+        const value = invocation.options[optionKey(flag)];
+        return typeof value === "string" || typeof value === "number" ? String(value) : undefined;
+    };
+    const repoFlag = selectorValue("--repo");
+    const runtimeCommand = resolveCliRuntimeCommand(process);
+    // hook-refresh is an internal machine-to-machine command. Keep it JSON even
+    // when an older installed hook predates the explicit --json argument.
+    const jsonOutput = invocation.options.json === true || cmd === "hook-refresh";
+    // `--json` is a shared output flag. Repair owns its richer --json/--jsonl
+    // parser; all other commands receive their original arguments minus it.
+    const rest = cmd === "repair" ? rawRest : rawRest.filter((argument) => argument !== "--json");
+    const selector = {
+        identity: selectorValue("--identity"),
+        file: selectorValue("--file"),
+        kind: selectorValue("--kind"),
+        toIdentity: selectorValue("--to-identity"),
+        toFile: selectorValue("--to-file"),
+        toKind: selectorValue("--to-kind"),
+    };
+    const responseBudget = {
+        bytes: selectorValue("--bytes") ? Number(selectorValue("--bytes")) : undefined,
+        tokens: selectorValue("--tokens") ? Number(selectorValue("--tokens")) : undefined,
+        items: selectorValue("--items") ? Number(selectorValue("--items")) : undefined,
+    };
+    for (const [flag, value, minimum] of [
+        ["--bytes", responseBudget.bytes, 256],
+        ["--tokens", responseBudget.tokens, 64],
+        ["--items", responseBudget.items, 1],
+    ]) {
+        if (value !== undefined && (!Number.isInteger(value) || value < minimum))
+            throw new Error(`knodin: ${flag} must be an integer >= ${minimum}`);
+    }
+    if (cmd === "init") {
+        explicitScope(rawRest);
+        const unsupported = rawRest.filter((argument, index) => {
+            if (argument === "--json" || argument.startsWith("--scope="))
+                return false;
+            if (argument === "--scope" || rawRest[index - 1] === "--scope")
+                return false;
+            return true;
+        });
+        if (unsupported.length > 0)
+            throw new Error(`knodin init: unknown option: ${unsupported[0]}`);
+    }
+    if (cmd === "configure") {
+        const status = rawRest.includes("--status");
+        const scope = explicitScope(rawRest);
+        const unsupported = rawRest.filter((argument, index) => {
+            if (argument === "--json" || argument === "--status" || argument.startsWith("--scope="))
+                return false;
+            if (argument === "--scope" || rawRest[index - 1] === "--scope")
+                return false;
+            return true;
+        });
+        if (unsupported.length > 0)
+            throw new Error(`knodin configure: unknown option: ${unsupported[0]}`);
+        if (status && scope)
+            throw new Error("knodin configure: --status and --scope are mutually exclusive");
+        if (!status && !scope)
+            throw new Error("knodin configure requires --scope personal|team|cli-only or --status");
+    }
+    if (cmd === "serve") {
+        const { startServer } = await import("../src/server.js");
+        await startServer();
+        return;
+    }
+    if (cmd === "fleet") {
+        if (repoFlag !== undefined) {
+            throw new Error("knodin fleet init accepts discovery roots, not --repo");
+        }
+        const plan = parseFleetInitArgs(rawRest, process.cwd());
+        if (!plan.json) {
+            process.stderr.write("warning: `knodin fleet init` is deprecated; use `knodin repos init --linked-worktrees=skip|include` (alias retained for two minor releases)\n");
+        }
+        const engine = createEngine();
+        const systemConfig = loadSystemConfiguration(plan.roots[0] ?? process.cwd());
+        const memoryLimitBytes = configuredRepositoryInitMemoryLimitBytes(systemConfig);
+        const summary = await initializeRepositories(plan.roots, {
+            command: runtimeCommand,
+            depth: plan.depth,
+            dryRun: plan.dryRun,
+            worktrees: plan.worktrees,
+            index: (target) => engine.index(target),
+            status: (target) => engine.status(target),
+            agents: detectSupportedAgents(),
+            indexMode: (target) => indexModeForPath(systemConfig, target),
+            isolatedInitialize: (target) => runRepositoryInitializationProcess({
+                repository: target,
+                command: runtimeCommand,
+                memoryLimitBytes,
+            }),
+        });
+        await engine.close();
+        process.stdout.write(plan.json ? `${JSON.stringify(summary)}\n` : formatRepositoryHuman(summary));
+        process.exitCode = summary.exitCode;
+        return;
+    }
+    if (cmd === "remote") {
+        await runRemoteCommand(rawRest);
+        return;
+    }
+    if (cmd === "repos") {
+        if (repoFlag !== undefined) {
+            throw new Error("knodin repos accepts discovery roots, not --repo");
+        }
+        const plan = parseRepositoryCommandArgs(rawRest, process.cwd());
+        if (plan.command === "discover") {
+            const discovery = await discoverRepositories(plan.roots, {
+                depth: plan.depth,
+                linkedWorktrees: plan.linkedWorktrees,
+            });
+            const engine = createEngine();
+            const systemConfig = loadSystemConfiguration(plan.roots[0] ?? process.cwd());
+            const repositories = [];
+            const discoveryRecords = plan.signals
+                ? discovery.repositories.slice(0, repositorySignalInspectionLimit(plan))
+                : discovery.repositories;
+            for (const record of discoveryRecords) {
+                const inventory = await inventoryRepository(record, {
+                    status: async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })),
+                    systemMemberships: (target) => systemMembershipsForPath(systemConfig, target),
+                });
+                repositories.push(withRepositorySignals(inventory, plan.signals, plan.signals ? await detectRepositorySignals(record.path) : {}));
+            }
+            await engine.close();
+            const output = {
+                schemaVersion: 1,
+                command: "discover",
+                linkedWorktrees: plan.linkedWorktrees,
+                ...discovery,
+                repositories,
+            };
+            const boundedOutput = plan.signals
+                ? applyResponseBudget(output, "repositories:discover", { bytes: plan.byteBudget, tokens: plan.tokenBudget, items: plan.itemBudget }, { bytes: 65_536, tokens: 16_384, items: 100 })
+                : output;
+            process.stdout.write(`${JSON.stringify(boundedOutput, null, plan.json ? 0 : 2)}\n`);
+            process.exitCode = discovery.issues.length > 0 ? 1 : 0;
+            return;
+        }
+        if (plan.command === "init") {
+            const systemConfig = loadSystemConfiguration(plan.roots[0] ?? process.cwd());
+            const memoryLimitBytes = plan.memoryLimitBytes ?? configuredRepositoryInitMemoryLimitBytes(systemConfig);
+            if (plan.dryRun) {
+                const summary = await initializeRepositories(plan.roots, {
+                    command: runtimeCommand,
+                    depth: plan.depth,
+                    dryRun: true,
+                    worktrees: plan.linkedWorktrees,
+                    manifestPath: plan.manifestPath,
+                    include: plan.include,
+                    exclude: plan.exclude,
+                    index: async () => undefined,
+                    status: async () => {
+                        throw new Error("dry-run must not inspect graph databases");
+                    },
+                    agents: detectSupportedAgents(),
+                    indexMode: (target) => indexModeForPath(systemConfig, target),
+                });
+                const planned = summary.results.reduce((counts, result) => {
+                    const key = result.plannedStatus ?? result.status;
+                    counts[key] = (counts[key] ?? 0) + 1;
+                    return counts;
+                }, {});
+                const output = {
+                    schemaVersion: 1,
+                    command: "init",
+                    dryRun: true,
+                    graphDatabasesOpened: 0,
+                    modelsLoaded: 0,
+                    selectedRepositories: summary.results.filter(({ message }) => message.startsWith("dry-run:")).length,
+                    planned,
+                    ...summary,
+                    repositories: [],
+                };
+                process.stdout.write(plan.json ? `${JSON.stringify(output)}\n` : formatRepositoryHuman(summary));
+                process.exitCode = summary.exitCode;
+                return;
+            }
+            const engine = createEngine();
+            const summary = await initializeRepositories(plan.roots, {
+                command: runtimeCommand,
+                depth: plan.depth,
+                dryRun: false,
+                worktrees: plan.linkedWorktrees,
+                manifestPath: plan.manifestPath,
+                include: plan.include,
+                exclude: plan.exclude,
+                index: (target) => engine.index(target),
+                status: (target) => engine.status(target),
+                agents: detectSupportedAgents(),
+                indexMode: (target) => indexModeForPath(systemConfig, target),
+                isolatedInitialize: (target) => runRepositoryInitializationProcess({
+                    repository: target,
+                    command: runtimeCommand,
+                    memoryLimitBytes,
+                }),
+            });
+            const discovery = await discoverRepositories(plan.roots, {
+                depth: plan.depth,
+                linkedWorktrees: plan.linkedWorktrees,
+            });
+            const repositories = [];
+            const selectedPaths = new Set(summary.results.map(({ repository }) => repository));
+            for (const record of discovery.repositories.filter(({ path }) => selectedPaths.has(path))) {
+                repositories.push(await inventoryRepository(record, {
+                    status: async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })),
+                    systemMemberships: (target) => systemMembershipsForPath(systemConfig, target),
+                }));
+            }
+            await engine.close();
+            const output = { schemaVersion: 1, command: "init", ...summary, repositories };
+            process.stdout.write(plan.json ? `${JSON.stringify(output)}\n` : formatRepositoryHuman(summary));
+            process.exitCode = summary.exitCode;
+            return;
+        }
+        if (plan.command === "search") {
+            const engine = createEngine();
+            const systemConfig = loadSystemConfiguration(plan.roots[0] ?? process.cwd());
+            const output = await searchRepositories(plan.roots, plan.query ?? "", {
+                depth: plan.depth,
+                linkedWorktrees: plan.linkedWorktrees,
+                include: plan.include,
+                exclude: plan.exclude,
+                allowPartial: plan.allowPartial,
+                itemBudget: plan.itemBudget,
+                byteBudget: plan.byteBudget,
+                tokenBudget: plan.tokenBudget,
+                cursor: plan.cursor,
+                status: async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })),
+                search: (query, target, limit, offset) => engine.search(query, target, limit, {
+                    offset,
+                    includeSource: true,
+                    federate: false,
+                }),
+                systemMemberships: (target) => systemMembershipsForPath(systemConfig, target),
+            });
+            await engine.close();
+            process.stdout.write(`${JSON.stringify(output, null, plan.json ? 0 : 2)}\n`);
+            process.exitCode = output.status === "unavailable" ? 1 : 0;
+            return;
+        }
+        const discovery = await discoverRepositories(plan.roots, {
+            depth: plan.depth,
+            linkedWorktrees: plan.linkedWorktrees,
+        });
+        const engine = createEngine();
+        const systemConfig = loadSystemConfiguration(plan.roots[0] ?? process.cwd());
+        const repositories = [];
+        for (const repository of discovery.repositories) {
+            try {
+                if (plan.command === "doctor") {
+                    const graph = attachLifecycleHealth(repository.path, await engine.status(repository.path, { audit: "deep" }));
+                    const inventory = await inventoryRepository(repository, {
+                        status: async () => graph,
+                        systemMemberships: (target) => systemMembershipsForPath(systemConfig, target),
+                    });
+                    repositories.push({
+                        ...inventory,
+                        diagnosis: await diagnoseInstallation(repository.path, {
+                            currentVersion: KNODIN_VERSION,
+                            runtimeCommand,
+                            graph,
+                        }),
+                    });
+                }
+                else {
+                    repositories.push(await inventoryRepository(repository, {
+                        status: async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })),
+                        systemMemberships: (target) => systemMembershipsForPath(systemConfig, target),
+                    }));
+                }
+            }
+            catch (error) {
+                repositories.push({
+                    path: repository.path,
+                    status: "unknown",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        await engine.close();
+        const output = {
+            schemaVersion: 1,
+            command: plan.command,
+            linkedWorktrees: plan.linkedWorktrees,
+            repositories,
+            issues: discovery.issues,
+            emptyRoots: discovery.emptyRoots,
+            staleLinkedWorktrees: discovery.staleLinkedWorktrees,
+        };
+        process.stdout.write(`${JSON.stringify(output, null, plan.json ? 0 : 2)}\n`);
+        process.exitCode =
+            discovery.issues.length > 0 ||
+                repositories.some((entry) => ("health" in entry && entry.health !== "healthy") ||
+                    ("status" in entry && entry.status === "unknown"))
+                ? 1
+                : 0;
+        return;
+    }
+    if (cmd === "docs") {
+        if (repoFlag !== undefined)
+            throw new Error("knodin docs does not accept --repo");
+        const [topic, ...unsupported] = rawRest;
+        if (unsupported.length > 0)
+            throw new Error(`knodin docs: unknown argument ${unsupported[0]}`);
+        if (!topic || topic === "list") {
+            process.stdout.write(`${listDocTopics().join("\n")}\n`);
+            return;
+        }
+        const content = getDocSection(topic);
+        if (!content)
+            throw new Error(`knodin docs: unknown topic ${topic}`);
+        process.stdout.write(content.endsWith("\n") ? content : `${content}\n`);
+        return;
+    }
+    if (cmd === "update") {
+        if (repoFlag !== undefined)
+            throw new Error("knodin update does not accept --repo");
+        const [action, ...unsupported] = rest;
+        if (!action || !["status", "check", "explain", "apply", "rollback"].includes(action)) {
+            throw new Error("knodin update requires status, check, explain, apply, or rollback");
+        }
+        if (unsupported.length > 0)
+            throw new Error(`knodin update ${action}: unknown argument ${unsupported[0]}`);
+        const method = detectUpdateInstallMethod(runtimeCommand);
+        const runManager = async (argv) => {
+            const [executable, ...arguments_] = argv;
+            if (!executable)
+                return { status: 1, stdout: "", stderr: "missing manager command" };
+            const outcome = spawnSync(executable, arguments_, {
+                encoding: "utf-8",
+                timeout: 120_000,
+                maxBuffer: 4 * 1_024 * 1_024,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            return {
+                status: outcome.status,
+                stdout: outcome.stdout ?? "",
+                stderr: outcome.stderr ?? outcome.error?.message ?? "",
+            };
+        };
+        const healthCheck = async () => {
+            const [executable, ...arguments_] = runtimeCommand;
+            if (!executable)
+                return false;
+            const outcome = spawnSync(executable, [...arguments_, "--version"], {
+                encoding: "utf-8",
+                timeout: 10_000,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            return outcome.status === 0 && /^\d+\.\d+\.\d+/.test(outcome.stdout.trim());
+        };
+        const options = {
+            currentVersion: KNODIN_VERSION,
+            installMethod: method,
+            env: process.env,
+            runManager,
+            healthCheck,
+        };
+        let output;
+        if (action === "status")
+            output = trustedUpdateStatus(options);
+        else if (action === "check") {
+            try {
+                output = await checkTrustedUpdate(options);
+            }
+            finally {
+                if (process.env.KNODIN_UPDATE_BACKGROUND === "1")
+                    releaseScheduledUpdateCheck();
+            }
+        }
+        else if (action === "explain")
+            output = explainTrustedUpdate(options);
+        else if (action === "apply")
+            output = await applyTrustedUpdate(options);
+        else
+            output = await rollbackTrustedUpdate(options);
+        process.stdout.write(jsonOutput ? `${JSON.stringify(output)}\n` : formatGenericHuman("update", output));
+        return;
+    }
+    if (process.stdout.isTTY &&
+        claimScheduledUpdateCheck({
+            currentVersion: KNODIN_VERSION,
+            installMethod: detectUpdateInstallMethod(runtimeCommand),
+            env: process.env,
+        })) {
+        const [executable, ...arguments_] = runtimeCommand;
+        if (executable) {
+            const background = spawn(executable, [...arguments_, "update", "check", "--json"], {
+                detached: true,
+                stdio: "ignore",
+                env: { ...process.env, KNODIN_UPDATE_BACKGROUND: "1" },
+            });
+            background.unref();
+        }
+    }
+    const resolved = resolveRepo(repoFlag, process.cwd());
+    if (!resolved.ok) {
+        process.stderr.write(`${resolved.error}\n`);
+        process.exit(1);
+    }
+    const repo = resolved.repo;
+    if (cmd === "doctor") {
+        const gitProbe = spawnSync(gitExecutable(), ["rev-parse", "--is-inside-work-tree"], {
+            cwd: repo,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (gitProbe.status !== 0 || gitProbe.stdout.trim() !== "true") {
+            const portfolio = {
+                schemaVersion: 1,
+                status: "portfolio-root",
+                path: repo,
+                graph: "not-inspected",
+                warning: "Target is not a Git worktree; treating a portfolio parent as one repository would be misleading.",
+                remediation: [`knodin repos doctor ${JSON.stringify(repo)}`],
+            };
+            process.stdout.write(jsonOutput ? `${JSON.stringify(portfolio)}\n` : formatGenericHuman("doctor", portfolio));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (cmd === "compress") {
+        const valueFlags = new Set([
+            "--strategy",
+            "--adapter",
+            "--lines",
+            "--max-output-bytes",
+            "--context",
+            "--exit-code",
+            "--signal",
+            "--max-input-bytes",
+            "--start",
+            "--end",
+            "--limit",
+            "--offset",
+        ]);
+        const positionals = rest.filter((argument, index) => !argument.startsWith("--") && !valueFlags.has(rest[index - 1]));
+        const integer = (flag, fallback, minimum, maximum) => {
+            const raw = selectorValue(flag);
+            const value = raw === undefined ? fallback : Number(raw);
+            if (!Number.isInteger(value) || value < minimum || value > maximum)
+                throw new Error(`knodin compress: ${flag} must be an integer from ${minimum} to ${maximum}`);
+            return value;
+        };
+        const action = positionals[0] === "read" || positionals[0] === "diagnose" || positionals[0] === "delete"
+            ? positionals[0]
+            : "create";
+        const artifactId = action === "create" ? undefined : positionals[1];
+        if (action !== "create" && !artifactId)
+            throw new Error(`knodin compress ${action} requires an artifact id`);
+        let compressionResult;
+        let diagnosisUnavailable = false;
+        if (action === "diagnose") {
+            const diagnosisEngine = createEngine();
+            try {
+                const health = await inspectGraphQueryHealth(repo, (target) => diagnosisEngine.status(target, { audit: "cached" }));
+                if (health.available) {
+                    compressionResult = await diagnoseFailure(diagnosisEngine, repo, {
+                        artifactId: artifactId ?? "",
+                        maxDiagnostics: integer("--limit", 10, 1, 50),
+                        diagnosticOffset: integer("--offset", 0, 0, 1_000_000),
+                        contextLines: integer("--context", 2, 0, 10),
+                        contextByteBudget: integer("--max-output-bytes", 16_384, 256, 128 * 1024),
+                    });
+                }
+                else {
+                    compressionResult = health;
+                    diagnosisUnavailable = true;
+                    process.exitCode = 1;
+                }
+            }
+            finally {
+                await diagnosisEngine.close();
+            }
+        }
+        else if (action === "read") {
+            compressionResult = readOutputArtifact(repo, artifactId ?? "", {
+                startLine: integer("--start", 1, 1, Number.MAX_SAFE_INTEGER),
+                endLine: selectorValue("--end")
+                    ? integer("--end", 200, 1, Number.MAX_SAFE_INTEGER)
+                    : undefined,
+                byteBudget: integer("--max-output-bytes", 16_384, 256, 4 * 1024 * 1024),
+                raw: rest.includes("--raw"),
+            });
+        }
+        else if (action === "delete") {
+            compressionResult = deleteOutputArtifact(repo, artifactId ?? "");
+        }
+        else {
+            const strategy = selectorValue("--strategy") ?? "smart";
+            if (!["smart", "head-tail", "errors-only"].includes(strategy))
+                throw new Error("knodin compress: invalid --strategy");
+            const adapter = selectorValue("--adapter") ?? "auto";
+            if (![
+                "auto",
+                "generic",
+                "vitest",
+                "jest",
+                "pytest",
+                "go-test",
+                "maven",
+                "gradle",
+                "dotnet",
+                "cargo",
+            ].includes(adapter))
+                throw new Error("knodin compress: invalid --adapter");
+            const maxInputBytes = integer("--max-input-bytes", 16 * 1024 * 1024, 1, 64 * 1024 * 1024);
+            const request = {
+                exitCode: selectorValue("--exit-code") ? integer("--exit-code", 0, 0, 255) : undefined,
+                signal: selectorValue("--signal"),
+                strategy: strategy,
+                adapter: adapter,
+                lineBudget: integer("--lines", 200, 1, 10_000),
+                byteBudget: integer("--max-output-bytes", 16_384, 256, 4 * 1024 * 1024),
+                contextLines: integer("--context", 1, 0, 10),
+                maxInputBytes,
+                retain: !rest.includes("--no-retain"),
+                redactSecrets: !rest.includes("--no-redact"),
+            };
+            const input = positionals[0] === "create" ? (positionals[1] ?? "-") : (positionals[0] ?? "-");
+            compressionResult =
+                input === "-"
+                    ? compressOutput(repo, { ...request, text: await readBoundedStdin(maxInputBytes) })
+                    : compressOutputFile(repo, input, request);
+        }
+        if (action === "diagnose" &&
+            (responseBudget.bytes !== undefined ||
+                responseBudget.tokens !== undefined ||
+                responseBudget.items !== undefined)) {
+            compressionResult = applyResponseBudget(compressionResult, "compress:diagnose", responseBudget, { bytes: 65_536, tokens: 16_384, items: 50 });
+        }
+        if (jsonOutput)
+            process.stdout.write(`${JSON.stringify(compressionResult)}\n`);
+        else if (action === "diagnose" && !diagnosisUnavailable)
+            process.stdout.write(formatFailureDiagnosisHuman(compressionResult));
+        else if (action === "diagnose")
+            process.stdout.write(formatGenericHuman("compress diagnose", compressionResult));
+        else if (action === "read")
+            process.stdout.write(formatCompressionReadHuman(compressionResult));
+        else if (action === "create")
+            process.stdout.write(formatCompressionHuman(compressionResult));
+        else
+            process.stdout.write(formatGenericHuman("compress delete", compressionResult));
+        return;
+    }
+    const engine = createEngine();
+    let result;
+    let repairOutput;
+    let repairWasPlan = false;
+    let repairExitCode = 0;
+    let statusWasWatched = false;
+    const graphRead = async (run) => {
+        const health = await inspectGraphQueryHealth(repo, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })));
+        if (!health.available) {
+            process.exitCode = 1;
+            return health;
+        }
+        const value = await run();
+        const verified = await inspectGraphQueryHealth(repo, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })));
+        if (!verified.available) {
+            process.exitCode = 1;
+            return verified;
+        }
+        return decorateGraphQueryResult(value, verified.state, verified.graph.freshness);
+    };
+    switch (cmd) {
+        case "doctor": {
+            const client = selectorValue("--client");
+            if (client !== undefined &&
+                !["claude", "codex", "gemini", "copilot", "antigravity"].includes(client))
+                throw new Error("knodin doctor: --client must be claude, codex, gemini, copilot, or antigravity");
+            const unsupported = rest.filter((argument, index) => argument !== "--client" && rest[index - 1] !== "--client");
+            if (unsupported.length > 0)
+                throw new Error(`knodin doctor: unknown option ${unsupported[0]}`);
+            const diagnosis = await diagnoseInstallation(repo, {
+                currentVersion: KNODIN_VERSION,
+                runtimeCommand: [...runtimeCommand, "serve"],
+                graph: await engine.status(repo, { audit: "deep" }),
+                client,
+            });
+            const manager = diagnosis.manager.name;
+            diagnosis.update = await checkTrustedUpdate({
+                currentVersion: KNODIN_VERSION,
+                installMethod: ["npm", "mise", "volta", "nvm", "fnm", "asdf", "homebrew"].includes(manager ?? "")
+                    ? manager
+                    : "unknown",
+                env: process.env,
+            });
+            result = diagnosis;
+            break;
+        }
+        case "system": {
+            const allowPartial = rest.includes("--allow-partial");
+            const [action, systemId, ...unsupported] = rest.filter((argument) => argument !== "--allow-partial");
+            if (!action || !["list", "show", "validate", "query"].includes(action)) {
+                throw new Error("knodin system requires list, show, validate, or query");
+            }
+            if (allowPartial && action !== "query")
+                throw new Error(`knodin system ${action}: --allow-partial applies only to query`);
+            if (unsupported.length > 0)
+                throw new Error(`knodin system ${action}: unknown argument ${unsupported[0]}`);
+            const config = await enrichSystemRelationships(loadSystemConfiguration(repo));
+            if (action === "list") {
+                if (systemId)
+                    throw new Error("knodin system list accepts no system id");
+                result = {
+                    schemaVersion: config.schemaVersion,
+                    systems: config.systems.map(({ id, components }) => ({
+                        id,
+                        componentCount: components.length,
+                    })),
+                };
+                break;
+            }
+            if (!systemId)
+                throw new Error(`knodin system ${action} requires <system-id>`);
+            const system = config.systems.find(({ id }) => id === systemId);
+            if (!system) {
+                result = {
+                    status: "not-found",
+                    systemId,
+                    available: config.systems.map(({ id }) => id),
+                };
+                process.exitCode = 1;
+                break;
+            }
+            if (action === "show") {
+                result = { status: "ok", system, repositories: config.repositories };
+            }
+            else if (action === "validate") {
+                const validation = await validateSystemHealth(config, systemId, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })), repo);
+                result = { systemId, ...validation };
+                if (!validation.valid)
+                    process.exitCode = 1;
+            }
+            else {
+                const validation = await validateSystemHealth(config, systemId, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })), repo);
+                result = queryConfiguredSystem(config, systemId, allowPartial, validation);
+                if (result.status === "unavailable")
+                    process.exitCode = 1;
+            }
+            break;
+        }
+        case "hook-refresh": {
+            const [kind, first, second] = rest;
+            let event;
+            if (kind === "commit")
+                event = { kind };
+            else if (kind === "checkout" && first && second) {
+                event = { kind, before: first, after: second };
+            }
+            else if (kind === "merge" && first && second) {
+                event = { kind, before: first, after: second };
+            }
+            else if (kind === "rewrite" && first) {
+                event = { kind, inputPath: first };
+            }
+            else {
+                throw new Error("knodin hook-refresh: invalid lifecycle event");
+            }
+            const indexed = await refreshFromGitEvent(repo, event, (target, files) => engine.index(target, files));
+            result = { indexed };
+            break;
+        }
+        case "init": {
+            const scope = await chooseInitScope(rawRest, repo);
+            const agents = scope === "team" ? [] : integrationAgents(repo);
+            const renderer = createInitRenderer();
+            const activity = createIndexActivityReporter(repo);
+            activity.start();
+            renderer.start();
+            let paths;
+            try {
+                try {
+                    paths = await initializeRepository(repo, {
+                        command: runtimeCommand,
+                        index: (target, options) => engine.index(target, undefined, false, options),
+                        scope,
+                        agents,
+                        onProgress: (event) => {
+                            activity.update(event);
+                            renderer.onProgress(event);
+                        },
+                    });
+                }
+                finally {
+                    await renderer.stop();
+                    activity.stop();
+                }
+            }
+            catch (error) {
+                if (!(error instanceof InitializationHealthError))
+                    throw error;
+                process.stderr.write(`${error.message}\n`);
+                await engine.close();
+                process.exitCode = 1;
+                return;
+            }
+            result = {
+                status: "success",
+                message: "knodin initialized successfully. Git lifecycle hooks configured.",
+                paths,
+            };
+            break;
+        }
+        case "configure": {
+            if (rawRest.includes("--status")) {
+                result = inspectRepositoryIntegrationStatus(repo) ?? {
+                    scope: "unconfigured",
+                    agents: [],
+                    warning: "AI agents are not configured by knodin. Run `knodin configure --scope personal`.",
+                };
+                break;
+            }
+            const scope = explicitScope(rawRest);
+            if (!scope)
+                throw new Error("knodin configure: missing --scope");
+            if (!fs.existsSync(resolveDbPath(repo))) {
+                throw new Error("knodin configure changes agent integration only; this repository is not initialized. Run `knodin init` first.");
+            }
+            const agents = scope === "team" ? [] : integrationAgents(repo);
+            const paths = await initializeRepository(repo, {
+                command: runtimeCommand,
+                index: async () => undefined,
+                scope,
+                agents,
+                allowTrackedTransition: true,
+                auditConfigurationChanges: true,
+            });
+            result = {
+                status: "success",
+                message: `knodin agent integration changed to ${scope}.`,
+                graphInitialization: "unchanged",
+                nextAction: "run `knodin status` and reload the configured client",
+                paths,
+            };
+            break;
+        }
+        case "index": {
+            // Target the repo unambiguously and never report success for a no-op:
+            // a lone directory positional means "index this repo", file positionals
+            // must resolve inside the repo, and a run touching zero files fails loud.
+            const positionals = extractPositionals(rest);
+            const plan = planIndex(repoFlag, positionals, process.cwd());
+            if (!plan.ok) {
+                process.stderr.write(`${plan.error}\n`);
+                await engine.close();
+                process.exit(1);
+            }
+            const clean = rest.includes("--clean") || rest.includes("--force");
+            const scipPath = selectorValue("--scip");
+            const sarifPath = selectorValue("--sarif");
+            // A bound the operator cannot move is just a failure, so every import
+            // ceiling is overridable. Reject junk here rather than letting NaN
+            // silently disable a limit downstream.
+            const importLimit = (flag) => {
+                const raw = selectorValue(flag);
+                if (raw === undefined)
+                    return undefined;
+                const parsed = Number(raw);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    process.stderr.write(`knodin index: ${flag} must be a positive integer\n`);
+                    process.exit(1);
+                }
+                return parsed;
+            };
+            const sarifMaxBytes = importLimit("--sarif-max-bytes");
+            const sarifMaxFindings = importLimit("--sarif-max-findings");
+            const sarifTimeoutMs = importLimit("--sarif-timeout-ms");
+            const scipMaxBytes = importLimit("--scip-max-bytes");
+            const scipMaxFiles = importLimit("--scip-max-files");
+            const scipMaxFacts = importLimit("--scip-max-facts");
+            const scipTimeoutMs = importLimit("--scip-timeout-ms");
+            const renderer = createInitRenderer("index");
+            const activity = createIndexActivityReporter(plan.repo);
+            activity.start();
+            renderer.start();
+            let indexResult;
+            try {
+                indexResult = await engine.index(plan.repo, plan.files, clean, {
+                    scip: scipPath
+                        ? {
+                            path: scipPath,
+                            // Only override a default when the operator actually asked.
+                            ...(scipMaxBytes !== undefined ? { maxBytes: scipMaxBytes } : {}),
+                            ...(scipMaxFiles !== undefined ? { maxFiles: scipMaxFiles } : {}),
+                            ...(scipMaxFacts !== undefined ? { maxFacts: scipMaxFacts } : {}),
+                            ...(scipTimeoutMs !== undefined ? { timeoutMs: scipTimeoutMs } : {}),
+                        }
+                        : undefined,
+                    sarif: sarifPath
+                        ? {
+                            path: sarifPath,
+                            // Only override a default when the operator actually asked.
+                            ...(sarifMaxBytes !== undefined ? { maxBytes: sarifMaxBytes } : {}),
+                            ...(sarifMaxFindings !== undefined ? { maxFindings: sarifMaxFindings } : {}),
+                            ...(sarifTimeoutMs !== undefined ? { timeoutMs: sarifTimeoutMs } : {}),
+                        }
+                        : undefined,
+                    onProgress: (event) => {
+                        activity.update(event);
+                        renderer.onProgress(event);
+                    },
+                });
+            }
+            finally {
+                await renderer.stop();
+                activity.stop();
+            }
+            result = indexResult;
+            const indexedCheck = checkIndexed([...indexResult.indexed, ...indexResult.unchanged], plan.repo);
+            if (!indexedCheck.ok) {
+                process.stderr.write(`${indexedCheck.error}\n`);
+                await engine.close();
+                process.exit(1);
+            }
+            if (indexResult.verification.status !== "healthy") {
+                process.stderr.write(formatIndexVerificationError(indexResult));
+                await engine.close();
+                process.exit(1);
+            }
+            break;
+        }
+        case "status": {
+            const snapshot = async () => ({
+                ...attachLifecycleHealth(repo, await engine.status(repo, {
+                    audit: rest.includes("--deep") ? "deep" : "cached",
+                })),
+                integration: inspectRepositoryIntegrationStatus(repo),
+                update: trustedUpdateStatus({
+                    currentVersion: KNODIN_VERSION,
+                    installMethod: detectUpdateInstallMethod(runtimeCommand),
+                    env: process.env,
+                }),
+            });
+            if (rest.includes("--watch")) {
+                const intervalRaw = selectorValue("--interval");
+                const intervalSeconds = intervalRaw === undefined ? 1 : Number(intervalRaw);
+                if (!Number.isFinite(intervalSeconds) || intervalSeconds < 0.1 || intervalSeconds > 60)
+                    throw new Error("knodin status: --interval must be between 0.1 and 60 seconds");
+                let watching = true;
+                const stop = () => {
+                    watching = false;
+                };
+                process.once("SIGINT", stop);
+                process.once("SIGTERM", stop);
+                while (watching) {
+                    const observed = await snapshot();
+                    process.stdout.write(`${JSON.stringify({ observedAt: new Date().toISOString(), ...observed })}\n`);
+                    await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1_000));
+                }
+                process.removeListener("SIGINT", stop);
+                process.removeListener("SIGTERM", stop);
+                statusWasWatched = true;
+                result = null;
+            }
+            else
+                result = await snapshot();
+            break;
+        }
+        case "wait": {
+            if (!rest.includes("--fresh"))
+                throw new Error("knodin wait requires --fresh");
+            const timeoutRaw = selectorValue("--timeout");
+            const timeoutSeconds = timeoutRaw === undefined ? 30 : Number(timeoutRaw);
+            if (!Number.isFinite(timeoutSeconds) || timeoutSeconds < 0 || timeoutSeconds > 300)
+                throw new Error("knodin wait: --timeout must be between 0 and 300 seconds");
+            result = await waitForFresh(engine, repo, Math.round(timeoutSeconds * 1_000));
+            if (result.status !== "fresh")
+                process.exitCode = 1;
+            break;
+        }
+        case "repair": {
+            const options = parseRepairCliArgs(rest);
+            if (options.plan) {
+                result = createRepairPlan(await engine.status(repo, { audit: "deep" }));
+                repairOutput = options.output;
+                repairWasPlan = true;
+                break;
+            }
+            const progressMode = resolveRepairProgressMode(options, process.env, process.stderr.isTTY);
+            const renderer = progressMode === "tty"
+                ? createProgressWorkerRenderer("repair-progress-worker", { type: "start" })
+                : (() => {
+                    const direct = createRepairProgressRenderer({
+                        mode: progressMode,
+                        intervalMs: options.progressIntervalMs,
+                        stdout: process.stdout,
+                        stderr: process.stderr,
+                    });
+                    return {
+                        start: () => direct.start(),
+                        onProgress: (event) => direct.onProgress(event),
+                        stop: async () => direct.stop(),
+                    };
+                })();
+            const controller = new AbortController();
+            const abortRepair = () => controller.abort();
+            process.once("SIGINT", abortRepair);
+            renderer.start();
+            try {
+                result = attachRepairLifecycle(repo, await engine.repair(repo, {
+                    signal: controller.signal,
+                    onProgress: (event) => renderer.onProgress(event),
+                }));
+            }
+            finally {
+                process.removeListener("SIGINT", abortRepair);
+                await renderer.stop();
+            }
+            repairOutput = options.output;
+            if (result.cancelled)
+                repairExitCode = 130;
+            break;
+        }
+        case "refresh-artifacts": {
+            const event = rest[0] ?? "code-change";
+            if (event !== "checkout" && event !== "merge" && event !== "code-change") {
+                process.stderr.write("knodin refresh-artifacts accepts checkout, merge, or code-change\n");
+                process.exit(1);
+            }
+            const refreshResult = refreshExternalGraphArtifacts(repo, event);
+            writeArtifactRefreshRecord(repo, refreshResult);
+            result = refreshResult;
+            break;
+        }
+        case "explain": {
+            const symbol = rest[0];
+            if (!symbol) {
+                process.stderr.write("knodin explain requires a <symbol>\n");
+                process.exit(1);
+            }
+            result = await graphRead(async () => {
+                const explained = await engine.explain(symbol, repo, rest[1] === "minimal" ? "minimal" : "standard", selector);
+                return rest[1] === "source" && !explained.ambiguity
+                    ? {
+                        mode: "source",
+                        identity: explained.identity,
+                        symbol: explained.symbol,
+                        source: explained.source,
+                        staleness: explained.staleness,
+                    }
+                    : explained;
+            });
+            break;
+        }
+        case "review": {
+            const plan = parseReviewArgs(rest);
+            result = await graphRead(() => engine.review(plan.base, repo, plan.detailLevel, plan.options));
+            break;
+        }
+        case "map":
+            result = await graphRead(() => engine.map(repo, rest.includes("--standard") ? "standard" : "minimal", {
+                topN: selectorValue("--top") ? Number(selectorValue("--top")) : undefined,
+                sort: selectorValue("--sort"),
+                relationKinds: selectorValue("--relations")?.split(",").filter(Boolean),
+            }));
+            break;
+        case "wiki": {
+            const health = await inspectGraphQueryHealth(repo, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })));
+            if (!health.available) {
+                result = health;
+                process.exitCode = 1;
+                break;
+            }
+            const force = rest.includes("--force");
+            const summary = await engine.wiki(repo, force);
+            await engine.close();
+            process.stdout.write(`wrote ${summary.written.length} pages, skipped ${summary.skipped.length}\n`);
+            process.exitCode = 0;
+            return;
+        }
+        case "visualize": {
+            const entry = rest.find((value, index) => !value.startsWith("--") && !rest[index - 1]?.startsWith("--"));
+            const outputPath = selectorValue("--output");
+            const scope = selectorValue("--scope");
+            const granularity = selectorValue("--granularity");
+            // Repo scope draws the whole graph, so it takes no entry selector.
+            if (!entry && scope !== "repo")
+                throw new Error("knodin visualize requires an <entry> selector");
+            if (!outputPath)
+                throw new Error("knodin visualize requires --output <path.html>");
+            result = await graphRead(() => writeVisualization(engine, repo, {
+                entry,
+                outputPath,
+                scope,
+                granularity,
+                depth: selectorValue("--depth") ? Number(selectorValue("--depth")) : undefined,
+                byteBudget: selectorValue("--max-bytes")
+                    ? Number(selectorValue("--max-bytes"))
+                    : undefined,
+                selector: {
+                    identity: selector.identity,
+                    file: selector.file,
+                    kind: selector.kind,
+                },
+            }));
+            break;
+        }
+        case "search": {
+            const query = rest[0];
+            if (!query) {
+                process.stderr.write("knodin search requires a <query>\n");
+                process.exit(1);
+            }
+            const positionalLimit = rest[1] && !rest[1].startsWith("--") ? rest[1] : undefined;
+            const limit = Number(selectorValue("--limit") ?? positionalLimit ?? 5);
+            if (!Number.isInteger(limit) || limit < 1)
+                throw new Error("knodin search: limit must be a positive integer");
+            let testScope = "all";
+            if (rest.includes("--tests-only"))
+                testScope = "test";
+            else if (rest.includes("--production-only"))
+                testScope = "production";
+            result = await graphRead(() => engine.search(query, repo, limit, {
+                languages: selectorValue("--languages")?.split(",").filter(Boolean),
+                extensions: selectorValue("--extensions")?.split(",").filter(Boolean),
+                kinds: selectorValue("--kinds")?.split(",").filter(Boolean),
+                path: selectorValue("--path"),
+                testScope,
+                includeSource: !rest.includes("--no-source"),
+                offset: selectorValue("--offset") ? Number(selectorValue("--offset")) : 0,
+            }));
+            break;
+        }
+        case "pack": {
+            const action = rest[0];
+            const diffScope = selectorValue("--diff-scope");
+            if (diffScope && !["unstaged", "staged", "all", "compare"].includes(diffScope))
+                throw new Error("knodin pack: invalid --diff-scope");
+            if (action === "read") {
+                if (!rest[1])
+                    throw new Error("knodin pack read requires an artifact path");
+                result = readPackedArtifact(repo, rest[1], Number(selectorValue("--start") ?? 1), Number(selectorValue("--end") ?? 200), Number(selectorValue("--bytes") ?? 16_384));
+            }
+            else if (action === "grep") {
+                if (!rest[1] || !rest[2])
+                    throw new Error("knodin pack grep requires an artifact path and regex");
+                result = grepPackedArtifact(repo, rest[1], rest[2], selectorValue("--flags") ?? "", Number(selectorValue("--limit") ?? 100));
+            }
+            else {
+                const policies = {};
+                for (const assignment of selectorValue("--policy")?.split(",") ?? []) {
+                    const [glob, policy] = assignment.split("=");
+                    if (!glob || !["full", "summary", "structure-only"].includes(policy))
+                        throw new Error("knodin pack: invalid --policy assignment");
+                    policies[glob] = policy;
+                }
+                result = exportContext(repo, {
+                    format: selectorValue("--format") ?? "markdown",
+                    include: selectorValue("--include")?.split(",").filter(Boolean),
+                    exclude: selectorValue("--exclude")?.split(",").filter(Boolean),
+                    policies,
+                    alreadyPresent: selectorValue("--already-present")?.split(",").filter(Boolean),
+                    chatFiles: selectorValue("--chat-files")?.split(",").filter(Boolean),
+                    lineNumbers: rest.includes("--line-numbers"),
+                    includeTree: rest.includes("--tree"),
+                    byteBudget: Number(selectorValue("--bytes") ?? 65_536),
+                    tokenBudget: Number(selectorValue("--tokens") ?? 16_384),
+                    outputPath: selectorValue("--output"),
+                    git: diffScope || selectorValue("--log")
+                        ? {
+                            diffScope: diffScope,
+                            from: selectorValue("--from"),
+                            to: selectorValue("--to"),
+                            log: selectorValue("--log") ? Number(selectorValue("--log")) : undefined,
+                        }
+                        : undefined,
+                });
+            }
+            break;
+        }
+        case "evidence": {
+            const level = rest[0];
+            const file = rest[1];
+            if (!file || !["locate", "outline", "evidence", "expand"].includes(level))
+                throw new Error("knodin evidence requires locate|outline|evidence|expand <file>");
+            result = deliverProgressiveEvidence({
+                repo,
+                file,
+                level,
+                continuation: selectorValue("--continuation"),
+                baselineHash: selectorValue("--baseline-hash"),
+                baselineBytes: selectorValue("--baseline-bytes")
+                    ? Number(selectorValue("--baseline-bytes"))
+                    : undefined,
+                startLine: selectorValue("--start") ? Number(selectorValue("--start")) : undefined,
+                endLine: selectorValue("--end") ? Number(selectorValue("--end")) : undefined,
+                byteLimit: responseBudget.bytes,
+                tokenLimit: responseBudget.tokens,
+                itemLimit: responseBudget.items,
+            });
+            break;
+        }
+        case "query": {
+            const pattern = rest[0];
+            const repoWide = REPO_WIDE_QUERY_PATTERNS.includes(pattern);
+            // architecture_overview's only positional is the detail level (minimal|
+            // standard), not a target — keep its target empty so it's not misreported.
+            const target = pattern === "architecture_overview" ||
+                pattern === "import_cycles" ||
+                rest[1]?.startsWith("--")
+                ? ""
+                : (rest[1] ?? "");
+            if (!pattern) {
+                process.stderr.write("knodin query requires a <pattern> (lsp_diagnostics|lsp_definitions|lsp_declarations|lsp_implementations|callers_of|callees_of|imports_of|importers_of|import_cycles|file_summary|batch_outline|project_overview|shortest_path|inheritors_of|structural_implementations_of|tests_for|impact|dead_code|large_functions|large_files|rename_preview|flows|flow_of|stats|traverse|feature_path|flow_analysis|knowledge_gaps|surprising_connections|suggested_questions|architecture_overview|community|triggers_of|publishers_of|listeners_of|handlers_of|endpoints_for|consumers_of|children_of|federated_repos|mcp_tools|api_contract_mismatches)\n");
+                process.exit(1);
+            }
+            const directionValue = selectorValue("--direction");
+            if (directionValue && !["upstream", "downstream", "both"].includes(directionValue)) {
+                process.stderr.write("knodin query: --direction must be upstream, downstream, or both\n");
+                process.exit(1);
+            }
+            const facetsValue = selectorValue("--facets")?.split(",").filter(Boolean);
+            if (facetsValue?.some((facet) => !["packages", "layers", "boundaries", "hotspots", "entryPoints", "languages"].includes(facet))) {
+                process.stderr.write("knodin query: --facets contains an unknown architecture facet\n");
+                process.exit(1);
+            }
+            if (!target && !repoWide) {
+                process.stderr.write(`knodin query ${pattern} requires a <target>\n`);
+                process.exit(1);
+            }
+            // shortest_path: `knodin query shortest_path <from> <to>`
+            // rename_preview: `knodin query rename_preview <old> <new>`
+            const to = pattern === "shortest_path" || pattern === "rename_preview" ? rest[2] : undefined;
+            if (pattern === "rename_preview" && !to) {
+                process.stderr.write("knodin query rename_preview requires <old> and <new>\n");
+                process.exit(1);
+            }
+            // traverse: `knodin query traverse <symbol> [--depth n | <n>]`. Depth is
+            // clamped (1-6) in the engine, so a raw value passes straight through.
+            let depth;
+            if (pattern === "traverse" || pattern === "feature_path" || pattern === "impact") {
+                const flagIdx = rest.indexOf("--depth");
+                const raw = flagIdx >= 0 ? rest[flagIdx + 1] : rest[2];
+                if (raw !== undefined && raw !== "" && Number.isFinite(Number(raw)))
+                    depth = Number(raw);
+            }
+            // architecture_overview: `knodin query architecture_overview [minimal|standard]`.
+            // Reuses the same detail knob as explain/review; minimal is the default.
+            let detailLevel;
+            if (pattern === "architecture_overview" && rest.includes("standard")) {
+                detailLevel = "standard";
+            }
+            const queryLimitRaw = selectorValue("--limit");
+            if (queryLimitRaw !== undefined &&
+                (!Number.isInteger(Number(queryLimitRaw)) || Number(queryLimitRaw) < 1)) {
+                process.stderr.write("knodin query: --limit must be a positive integer\n");
+                process.exit(1);
+            }
+            const queryHealth = pattern.startsWith("lsp_")
+                ? null
+                : await inspectGraphQueryHealth(repo, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })));
+            if (queryHealth && !queryHealth.available) {
+                result = queryHealth;
+                process.exitCode = 1;
+                break;
+            }
+            result = await engine.query(pattern, target, repo, to, queryLimitRaw ? Number(queryLimitRaw) : undefined, depth, detailLevel, selector, pattern === "impact"
+                ? {
+                    mode: selectorValue("--impact-mode") === "file" ? "file" : "symbol",
+                    direction: ["upstream", "downstream", "both"].includes(selectorValue("--direction") ?? "")
+                        ? selectorValue("--direction")
+                        : undefined,
+                    relationKinds: selectorValue("--relations")
+                        ?.split(",")
+                        .map((kind) => kind.trim())
+                        .filter(Boolean),
+                    minConfidence: selectorValue("--min-confidence")
+                        ? Number(selectorValue("--min-confidence"))
+                        : undefined,
+                    includeTests: !rest.includes("--exclude-tests"),
+                    includeDataFlow: rest.includes("--data-flow"),
+                }
+                : undefined, {
+                minLines: selectorValue("--min-lines") ? Number(selectorValue("--min-lines")) : undefined,
+                minComplexity: selectorValue("--min-complexity")
+                    ? Number(selectorValue("--min-complexity"))
+                    : undefined,
+                kinds: selectorValue("--kinds")?.split(",").filter(Boolean),
+                path: selectorValue("--path"),
+                direction: pattern === "traverse" &&
+                    ["upstream", "downstream", "both"].includes(selectorValue("--direction") ?? "")
+                    ? selectorValue("--direction")
+                    : undefined,
+                includeDataFlow: pattern === "traverse" ? rest.includes("--data-flow") : undefined,
+                flowVariable: pattern === "flow_analysis" ? selectorValue("--variable") : undefined,
+                architectureFacets: facetsValue,
+                topN: selectorValue("--top") ? Number(selectorValue("--top")) : undefined,
+                sort: selectorValue("--sort"),
+                relationKinds: pattern === "impact"
+                    ? undefined
+                    : selectorValue("--relations")?.split(",").filter(Boolean),
+                detailLevel,
+            });
+            if (pattern === "impact" || pattern === "dead_code") {
+                const config = await enrichSystemRelationships(loadSystemConfiguration(repo));
+                result = incorporateSystemQueryEvidence(config, repo, pattern, target, result);
+            }
+            if (queryHealth?.available) {
+                const verifiedQueryHealth = await inspectGraphQueryHealth(repo, async (target) => attachLifecycleHealth(target, await engine.status(target, { audit: "cached" })));
+                if (!verifiedQueryHealth.available) {
+                    result = verifiedQueryHealth;
+                    process.exitCode = 1;
+                    break;
+                }
+                result = decorateGraphQueryResult(result, verifiedQueryHealth.state, verifiedQueryHealth.graph.freshness);
+            }
+            break;
+        }
+        case "rename": {
+            // knodin rename <old> <new> [--apply] [--no-verify]
+            const positional = rest.filter((a) => !a.startsWith("--"));
+            const oldName = positional[0];
+            const newName = positional[1];
+            const apply = rest.includes("--apply");
+            // Post-apply typecheck is on by default; --no-verify opts out.
+            const verify = !rest.includes("--no-verify");
+            if (!oldName || !newName) {
+                process.stderr.write("knodin rename requires <old> and <new>\n");
+                process.exit(1);
+            }
+            result = await graphRead(() => engine.rename(oldName, newName, repo, apply, verify, selector));
+            break;
+        }
+        case "prs": {
+            try {
+                const args = rest[0] === "audit" ? rest.slice(1) : rest;
+                const flag = (name) => {
+                    const index = args.indexOf(name);
+                    return index >= 0 ? args[index + 1] : undefined;
+                };
+                const state = flag("--state");
+                const limitValue = flag("--limit");
+                const limit = limitValue === undefined ? 50 : Number(limitValue);
+                if (!Number.isInteger(limit) || limit < 1)
+                    throw new Error("knodin prs: --limit must be a positive integer");
+                result = await auditPullRequests(repo, engine, {
+                    state,
+                    limit,
+                    branches: flag("--branches"),
+                    range: flag("--range"),
+                    base: flag("--base"),
+                    head: flag("--head"),
+                    expectedLogin: flag("--expected-login"),
+                });
+            }
+            catch (err) {
+                await engine.close();
+                process.stderr.write(`${err.message}\n`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "worktrees": {
+            const action = rest[0] ?? "status";
+            if (action === "status") {
+                result = await inspectWorktrees(repo, (worktree) => engine.status(worktree, { audit: "cached" }));
+            }
+            else if (action === "reconcile") {
+                result = reconcileWorktrees(repo);
+            }
+            else if (action === "remove") {
+                const target = rest[1];
+                if (!target)
+                    throw new Error("knodin worktrees remove requires <path>");
+                result = removeManagedWorktree(repo, target, rest.includes("--dry-run"));
+            }
+            else {
+                throw new Error(`knodin worktrees: unknown action ${action}`);
+            }
+            break;
+        }
+        case "telemetry": {
+            const action = rest[0];
+            const rawRetention = selectorValue("--retention-days");
+            const retentionDays = rawRetention === undefined ? 30 : Number(rawRetention);
+            if (!Number.isInteger(retentionDays) || retentionDays < 1 || retentionDays > 3650)
+                throw new Error("knodin telemetry: --retention-days must be an integer from 1 to 3650");
+            const input = selectorValue("--input");
+            if (action === "status")
+                result = telemetryStatus(repo, input, retentionDays);
+            else if (action === "report")
+                result = writeTelemetryReport(repo, readTelemetryRecords(repo, input, retentionDays), selectorValue("--output"));
+            else if (action === "export")
+                result = exportTelemetry(repo, readTelemetryRecords(repo, input, retentionDays), selectorValue("--output"));
+            else if (action === "clear")
+                result = clearTelemetry(repo, input);
+            else
+                throw new Error("knodin telemetry requires status, report, export, or clear");
+            break;
+        }
+        case "diagnostics": {
+            const [action, bundlePath] = invocation.positionals;
+            const rawRetention = selectorValue("--retention-days");
+            const sinceOption = selectorValue("--since");
+            const outputOption = selectorValue("--output");
+            const previewId = selectorValue("--preview-id");
+            const retentionDays = rawRetention === undefined ? 14 : Number(rawRetention);
+            if (!Number.isInteger(retentionDays) || retentionDays < 1 || retentionDays > 365)
+                throw new Error("knodin diagnostics: --retention-days must be an integer from 1 to 365");
+            if (bundlePath && action !== "inspect")
+                throw new Error(`knodin diagnostics ${action}: unexpected bundle argument`);
+            if (rawRetention !== undefined && action !== "enable")
+                throw new Error(`knodin diagnostics ${action}: --retention-days applies only to enable`);
+            if (sinceOption !== undefined && !["preview", "archive", "collect"].includes(action ?? ""))
+                throw new Error(`knodin diagnostics ${action}: --since applies only to preview or archive`);
+            if (outputOption !== undefined && !["archive", "collect"].includes(action ?? ""))
+                throw new Error(`knodin diagnostics ${action}: --output applies only to archive`);
+            if (previewId !== undefined && !["archive", "collect"].includes(action ?? ""))
+                throw new Error(`knodin diagnostics ${action}: --preview-id applies only to archive`);
+            if (action === "enable")
+                result = enableDiagnostics(repo, retentionDays);
+            else if (action === "status")
+                result = diagnosticsStatus(repo);
+            else if (action === "disable")
+                result = disableDiagnostics(repo);
+            else if (action === "clear")
+                result = clearDiagnostics(repo);
+            else if (action === "inspect") {
+                if (!bundlePath)
+                    throw new Error("knodin diagnostics inspect requires <bundle>");
+                result = inspectDiagnosticsBundle(repo, bundlePath);
+            }
+            else if (["preview", "archive", "collect"].includes(action ?? "")) {
+                const since = sinceOption ?? "24h";
+                const match = /^(\d+)([hd])$/.exec(since);
+                if (!match)
+                    throw new Error("knodin diagnostics collect: --since must be hours or days, such as 24h or 7d");
+                const sinceHours = Number(match[1]) * (match[2] === "d" ? 24 : 1);
+                let graph;
+                let doctor;
+                try {
+                    graph = attachLifecycleHealth(repo, await engine.status(repo, { audit: "deep" }));
+                }
+                catch {
+                    // Support evidence remains available with an explicit unavailable graph section.
+                }
+                if (graph) {
+                    try {
+                        doctor = await diagnoseInstallation(repo, {
+                            currentVersion: KNODIN_VERSION,
+                            runtimeCommand: [...runtimeCommand, "serve"],
+                            graph,
+                        });
+                    }
+                    catch {
+                        // Installation diagnosis is represented as unavailable in the manifest.
+                    }
+                }
+                const options = {
+                    sinceHours,
+                    doctor,
+                    graph,
+                    knodinVersion: KNODIN_VERSION,
+                };
+                result =
+                    action === "preview"
+                        ? persistDiagnosticsPreview(repo, options)
+                        : collectDiagnostics(repo, { ...options, outputPath: outputOption, previewId });
+            }
+            else {
+                throw new Error("knodin diagnostics requires enable, status, preview, archive, inspect, clear, or disable");
+            }
+            break;
+        }
+        case "context": {
+            // knodin context "<task>" [base]
+            const task = rest[0];
+            if (!task) {
+                process.stderr.write('knodin context requires a "<task>" description\n');
+                process.exit(1);
+            }
+            result = await graphRead(() => buildKnodinContext(engine, task, repo, rest[1]));
+            break;
+        }
+        default:
+            process.stderr.write(`unknown command: ${cmd}\n\n${renderCliHelp([], process.stderr.isTTY ? process.stderr.columns : undefined)}`);
+            process.exit(1);
+    }
+    await engine.close();
+    if (statusWasWatched)
+        return;
+    const boundedResult = applyResponseBudget(result, cmd, responseBudget, {
+        bytes: 65_536,
+        tokens: 16_384,
+        items: 100,
+    });
+    const finalExitCode = Math.max(Number(process.exitCode ?? 0), repairExitCode);
+    if (cmd === "init" && !jsonOutput) {
+        process.stdout.write(formatInitHuman(boundedResult));
+        process.exitCode = finalExitCode;
+        return;
+    }
+    if (cmd === "configure" && !jsonOutput && !rawRest.includes("--status")) {
+        process.stdout.write(formatConfigureHuman(boundedResult));
+        return;
+    }
+    if (cmd === "configure" && !jsonOutput && rawRest.includes("--status")) {
+        process.stdout.write(formatConfigureStatusHuman(boundedResult));
+        return;
+    }
+    if (cmd === "repair" && repairOutput === "human" && !repairWasPlan) {
+        process.stdout.write(formatRepairHuman(boundedResult));
+        process.exitCode = finalExitCode;
+        return;
+    }
+    if (cmd === "index" && !jsonOutput) {
+        // Human counts must describe the actual operation. The response budget is
+        // a JSON transport constraint and may truncate large `indexed` arrays.
+        process.stdout.write(formatIndexHuman(result));
+        process.exitCode = finalExitCode;
+        return;
+    }
+    if (cmd === "status" && !jsonOutput) {
+        process.stdout.write(formatStatusHuman(boundedResult));
+        process.exitCode = finalExitCode;
+        return;
+    }
+    if (!jsonOutput && repairOutput !== "jsonl") {
+        process.stdout.write(formatGenericHuman(cmd, boundedResult));
+        process.exitCode = finalExitCode;
+        return;
+    }
+    // Budget accounting is over the exact compact serialization written here.
+    process.stdout.write(repairOutput === "jsonl"
+        ? serializeRepairJsonlRecord("result", boundedResult)
+        : `${JSON.stringify(boundedResult)}\n`);
+    process.exitCode = finalExitCode;
+}
+try {
+    await main();
+}
+catch (err) {
+    const argv = process.argv.slice(2);
+    const repoIndex = argv.indexOf("--repo");
+    const equalsRepo = argv.find((argument) => argument.startsWith("--repo="));
+    const explicitRepo = repoIndex >= 0 ? argv[repoIndex + 1] : undefined;
+    let candidate = process.cwd();
+    if (explicitRepo)
+        candidate = explicitRepo;
+    else if (equalsRepo)
+        candidate = equalsRepo.slice("--repo=".length);
+    const command = argv.find((argument, index) => {
+        if (argument.startsWith("-"))
+            return false;
+        return !(index > 0 && argv[index - 1] === "--repo") && argument !== candidate;
+    });
+    const knownCommands = new Set([
+        "init",
+        "configure",
+        "index",
+        "doctor",
+        "status",
+        "wait",
+        "repair",
+        "serve",
+        "context",
+        "explain",
+        "review",
+        "map",
+        "search",
+        "query",
+        "rename",
+        "wiki",
+        "visualize",
+        "pack",
+        "compress",
+        "prs",
+        "worktrees",
+        "telemetry",
+        "diagnostics",
+        "system",
+        "repos",
+        "remote",
+        "update",
+    ]);
+    const diagnostic = recordDiagnosticFailure(candidate, {
+        surface: "cli",
+        operation: command && knownCommands.has(command) ? command : "unknown",
+        phase: "dispatch",
+        error: err,
+    });
+    const correlation = diagnostic.recorded ? ` [diagnostic ${diagnostic.correlationId}]` : "";
+    console.error(`${err instanceof Error ? err.message : String(err)}${correlation}`);
+    process.exit(1);
+}