@shidesheng0218/agentguard 0.8.0

package/dist/cli.js

@@ -0,0 +1,2857 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs10 from "fs";
+import { Command } from "commander";
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var version = pkg.version;
+
+// src/config.ts
+import fs2 from "fs";
+import { parse as parseToml } from "smol-toml";
+
+// src/paths.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function guardHome() {
+  const env = process.env.AGENT_GUARD_HOME ?? process.env.KIMI_GUARD_HOME;
+  if (env && env.trim()) return path.resolve(env);
+  const fresh = path.join(os.homedir(), ".agent-guard");
+  const legacy = path.join(os.homedir(), ".kimi-guard");
+  if (!fs.existsSync(fresh) && fs.existsSync(legacy)) return legacy;
+  return fresh;
+}
+function claudeSettingsPath() {
+  const env = process.env.CLAUDE_SETTINGS_PATH;
+  if (env && env.trim()) return path.resolve(env);
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+function claudeDetected() {
+  return fs.existsSync(claudeSettingsPath()) || fs.existsSync(path.join(os.homedir(), ".claude"));
+}
+function stateDbPath() {
+  return path.join(guardHome(), "state.db");
+}
+function probeLogPath() {
+  return path.join(guardHome(), "probe.jsonl");
+}
+function userConfigPath() {
+  return path.join(guardHome(), "config.toml");
+}
+function detectKimiConfig() {
+  const env = process.env.KIMI_CONFIG_PATH;
+  if (env && env.trim()) {
+    const p = path.resolve(env);
+    return { path: p, exists: fs.existsSync(p) };
+  }
+  const candidates = [
+    path.join(os.homedir(), ".kimi-code", "config.toml"),
+    path.join(os.homedir(), ".kimi", "config.toml")
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return { path: p, exists: true };
+  }
+  return { path: candidates[0], exists: false };
+}
+
+// src/toolsets.ts
+var DEFAULT_EDIT_TOOLS = ["WriteFile", "StrReplaceFile", "Edit", "Write", "MultiEdit", "NotebookEdit"];
+var DEFAULT_READ_TOOLS = ["ReadFile", "Read"];
+var DEFAULT_SEARCH_TOOLS = ["Grep", "Glob"];
+var DEFAULT_SHELL_TOOLS = ["Shell", "Bash"];
+var CLAUDE_EDIT_TOOLS = ["Write", "Edit", "MultiEdit", "NotebookEdit"];
+var CLAUDE_READ_TOOLS = ["Read"];
+var CLAUDE_SEARCH_TOOLS = ["Grep", "Glob"];
+var CLAUDE_SHELL_TOOLS = ["Bash"];
+function toolDefaultsFor(harness) {
+  return harness === "claude" ? { edit: [...CLAUDE_EDIT_TOOLS], read: [...CLAUDE_READ_TOOLS], search: [...CLAUDE_SEARCH_TOOLS], shell: [...CLAUDE_SHELL_TOOLS] } : { edit: [...DEFAULT_EDIT_TOOLS], read: [...DEFAULT_READ_TOOLS], search: [...DEFAULT_SEARCH_TOOLS], shell: [...DEFAULT_SHELL_TOOLS] };
+}
+function resolve(list, fallback) {
+  return new Set(list.length > 0 ? list : fallback);
+}
+function editTools(cfg) {
+  return resolve(cfg.tools.edit, DEFAULT_EDIT_TOOLS);
+}
+function readTools(cfg) {
+  return resolve(cfg.tools.read, DEFAULT_READ_TOOLS);
+}
+function searchTools(cfg) {
+  return resolve(cfg.tools.search, DEFAULT_SEARCH_TOOLS);
+}
+function shellTools(cfg) {
+  return resolve(cfg.tools.shell, DEFAULT_SHELL_TOOLS);
+}
+
+// src/config.ts
+var defaultConfig = {
+  harness: "kimi",
+  tools: toolDefaultsFor("kimi"),
+  repeat: {
+    enabled: true,
+    maxRepeats: 3,
+    warnAt: 2,
+    windowMinutes: 30,
+    watch: ["Grep", "Glob", "Shell", "Bash", "FetchURL", "SearchWeb", "ReadFile"],
+    thresholds: { ReadFile: 5 },
+    exemptPatterns: []
+  },
+  cycle: { enabled: true, windowMinutes: 30 },
+  noProgress: { enabled: true, windowMinutes: 30, warnAt: 15, blockAt: 25 },
+  nearRepeat: { enabled: true, windowMinutes: 30, warnAt: 6, blockAt: 10 },
+  explore: { enabled: true, windowMinutes: 30, warnAt: 10, blockAt: 15 },
+  verify: {
+    enabled: true,
+    blockOnNoEvidence: false,
+    evidenceWindowMinutes: 60,
+    claimPatterns: [],
+    evidencePatterns: [],
+    shellTools: ["Shell", "Bash"],
+    veto: {
+      enabled: false,
+      model: "kimi-k3",
+      baseUrl: "https://api.moonshot.cn/v1",
+      maxCallsPerSession: 3,
+      timeoutMs: 1e4
+    }
+  },
+  thinking: { enabled: true, minThinkChars: 2e4, maxTextRatio: 0.1 },
+  anchor: { enabled: true, everyNPrompts: 5, maxChars: 1e3 },
+  context: { enabled: true, warnPercent: 85 },
+  noGain: { enabled: true, windowMinutes: 30, warnAt: 3, blockAt: 4 },
+  churn: {
+    enabled: true,
+    windowMinutes: 30,
+    warnAt: 5,
+    blockAt: 10,
+    tools: ["WriteFile", "StrReplaceFile", "Edit", "Write", "MultiEdit", "NotebookEdit"]
+  },
+  policy: { killSwitch: true, maxBlocksPerSession: 5, blockWindowMinutes: 60 },
+  budget: {
+    enabled: true,
+    plan: "tier1",
+    weekly: 0,
+    fiveHour: 0,
+    dispatchTools: ["Task", "Agent"],
+    reservePercent: 10,
+    subagentWeight: 5,
+    warnPercent: 80,
+    precise: false,
+    preciseUrl: "",
+    preciseCacheSeconds: 300
+  },
+  probe: false
+};
+var CONFIG_TEMPLATE = `# agent-guard configuration
+# Docs: https://github.com/shidesheng0218/kimi-guard
+
+[tools]                   # canonical tool-name taxonomy \u2014 if your CLI version renames tools, fix it HERE
+edit = ["WriteFile", "StrReplaceFile", "Edit", "Write", "MultiEdit", "NotebookEdit"]
+read = ["ReadFile", "Read"]
+search = ["Grep", "Glob"]
+shell = ["Shell", "Bash"]
+
+[repeat]
+enabled = true
+maxRepeats = 3            # identical (tool, args) calls allowed per window
+warnAt = 2                # soft context warning before the hard block
+windowMinutes = 30
+watch = ["Grep", "Glob", "Shell", "Bash", "FetchURL", "SearchWeb", "ReadFile"]
+# exemptPatterns = ["git status"]  # regexes over JSON-serialized args; matching calls are never repeat-blocked (polling commands like git status, sleep)
+
+[repeat.thresholds]       # per-tool overrides
+ReadFile = 5
+
+[cycle]                   # A->B->A->B oscillation detection
+enabled = true
+windowMinutes = 30
+
+[noProgress]              # long stretch of calls with no successful edit
+enabled = true
+windowMinutes = 30
+warnAt = 15
+blockAt = 25
+
+[nearRepeat]              # fuzzy near-duplicates (punctuation/case/order differences)
+enabled = true
+windowMinutes = 30
+warnAt = 6
+blockAt = 10
+
+[explore]                 # pure-exploration streak: reads/searches with no action in between
+enabled = true
+windowMinutes = 30
+warnAt = 10
+blockAt = 15
+
+[verify]                  # completion-claim gate: "tests pass" must be backed by a real run
+enabled = true
+blockOnNoEvidence = false # hooks path: block Stop when edits landed but nothing was verified
+evidenceWindowMinutes = 60
+# deprecated: shell tool names now live in [tools] shell (this key still works)
+
+[verify.veto]             # optional LLM veto vote to suppress false positives (self-critic style)
+enabled = false           # requires KIMI_GUARD_VETO_API_KEY in the environment
+model = "kimi-k3"         # use a cheap fast model \u2014 the LLM only votes, never authors
+baseUrl = "https://api.moonshot.cn/v1"
+maxCallsPerSession = 3    # anti "vote-laundering" cap: the model cannot retry its way out
+timeoutMs = 10000
+
+[thinking]                # thinking-dominance (pure-reasoning turns), Wire mode only
+enabled = true
+minThinkChars = 20000
+maxTextRatio = 0.1
+
+[anchor]                  # goal anchoring: re-inject the original task periodically
+enabled = true
+everyNPrompts = 5         # re-inject the goal every N prompts / steps
+maxChars = 1000
+
+[context]                 # context-fill gate (Wire mode reads StatusUpdate.context_usage)
+enabled = true
+warnPercent = 85          # steer a wrap-up warning when context is this full
+
+[noGain]                  # different args, byte-identical output
+enabled = true
+windowMinutes = 30
+warnAt = 3
+blockAt = 4
+
+[churn]                   # same file edited over and over
+enabled = true
+windowMinutes = 30
+warnAt = 5
+blockAt = 10
+# deprecated: edit tool names now live in [tools] edit (this key still works)
+
+[policy]
+killSwitch = true         # after maxBlocksPerSession interventions, block ALL tools
+maxBlocksPerSession = 5
+blockWindowMinutes = 60
+
+[budget]                  # request accounting for Kimi Coding Plans
+enabled = true
+plan = "tier1"            # tier1: 1024/week | tier2: 2048 | tier3: 7168 (200 per 5h)
+weekly = 0                # override weekly requests (0 = use plan preset)
+fiveHour = 0              # override 5h requests (0 = use plan preset)
+dispatchTools = ["Task", "Agent"]
+reservePercent = 10       # keep this much headroom for you, not the agent
+subagentWeight = 5        # ~requests each dispatched subagent costs
+warnPercent = 80
+precise = false           # poll the official Kimi usage API for exact windows (needs KIMI_API_KEY, sk-kimi-...)
+preciseUrl = ""           # default https://api.kimi.com/coding/v1
+preciseCacheSeconds = 300 # the API is rate-limited; cache aggressively. Falls back to event-based on any error
+
+[probe]
+enabled = false
+`;
+function applyClaudeDefaults(cfg) {
+  cfg.tools = toolDefaultsFor("claude");
+  cfg.repeat.watch = ["Grep", "Glob", "Bash", "Read", "WebFetch", "WebSearch"];
+  cfg.repeat.thresholds = { Read: 5 };
+  cfg.budget.dispatchTools = ["Task"];
+}
+function num(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function bool(v, fallback) {
+  return typeof v === "boolean" ? v : fallback;
+}
+function strArr(v, fallback) {
+  return Array.isArray(v) && v.every((x) => typeof x === "string") && v.length > 0 ? v : fallback;
+}
+function strArrOrNull(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "string") && v.length > 0 ? v : null;
+}
+function loadConfig(configPath = userConfigPath(), harness = "kimi") {
+  const cfg = structuredClone(defaultConfig);
+  cfg.harness = harness;
+  if (harness === "claude") applyClaudeDefaults(cfg);
+  let raw;
+  try {
+    raw = fs2.readFileSync(configPath, "utf8");
+  } catch {
+    return cfg;
+  }
+  let data;
+  try {
+    data = parseToml(raw);
+  } catch (err) {
+    process.stderr.write(`[agent-guard] failed to parse ${configPath}: ${err.message}
+`);
+    return cfg;
+  }
+  const section = (name) => data[name] ?? {};
+  const tools = section("tools");
+  const toolsEdit = strArrOrNull(tools["edit"]);
+  const toolsRead = strArrOrNull(tools["read"]);
+  const toolsSearch = strArrOrNull(tools["search"]);
+  const toolsShell = strArrOrNull(tools["shell"]);
+  if (toolsEdit) cfg.tools.edit = toolsEdit;
+  if (toolsRead) cfg.tools.read = toolsRead;
+  if (toolsSearch) cfg.tools.search = toolsSearch;
+  if (toolsShell) cfg.tools.shell = toolsShell;
+  const repeat = section("repeat");
+  cfg.repeat.enabled = bool(repeat["enabled"], cfg.repeat.enabled);
+  cfg.repeat.maxRepeats = num(repeat["maxRepeats"], cfg.repeat.maxRepeats);
+  cfg.repeat.warnAt = num(repeat["warnAt"], cfg.repeat.warnAt);
+  cfg.repeat.windowMinutes = num(repeat["windowMinutes"], cfg.repeat.windowMinutes);
+  cfg.repeat.watch = strArr(repeat["watch"], cfg.repeat.watch);
+  const exempt = repeat["exemptPatterns"];
+  if (Array.isArray(exempt)) cfg.repeat.exemptPatterns = exempt.filter((p) => typeof p === "string");
+  const th = repeat["thresholds"];
+  if (th) {
+    for (const [k, v] of Object.entries(th)) if (typeof v === "number") cfg.repeat.thresholds[k] = v;
+  }
+  const cycle = section("cycle");
+  cfg.cycle.enabled = bool(cycle["enabled"], cfg.cycle.enabled);
+  cfg.cycle.windowMinutes = num(cycle["windowMinutes"], cfg.cycle.windowMinutes);
+  const noProgress = section("noProgress");
+  cfg.noProgress.enabled = bool(noProgress["enabled"], cfg.noProgress.enabled);
+  cfg.noProgress.windowMinutes = num(noProgress["windowMinutes"], cfg.noProgress.windowMinutes);
+  cfg.noProgress.warnAt = num(noProgress["warnAt"], cfg.noProgress.warnAt);
+  cfg.noProgress.blockAt = num(noProgress["blockAt"], cfg.noProgress.blockAt);
+  const nearRepeat = section("nearRepeat");
+  cfg.nearRepeat.enabled = bool(nearRepeat["enabled"], cfg.nearRepeat.enabled);
+  cfg.nearRepeat.windowMinutes = num(nearRepeat["windowMinutes"], cfg.nearRepeat.windowMinutes);
+  cfg.nearRepeat.warnAt = num(nearRepeat["warnAt"], cfg.nearRepeat.warnAt);
+  cfg.nearRepeat.blockAt = num(nearRepeat["blockAt"], cfg.nearRepeat.blockAt);
+  const explore = section("explore");
+  cfg.explore.enabled = bool(explore["enabled"], cfg.explore.enabled);
+  cfg.explore.windowMinutes = num(explore["windowMinutes"], cfg.explore.windowMinutes);
+  cfg.explore.warnAt = num(explore["warnAt"], cfg.explore.warnAt);
+  cfg.explore.blockAt = num(explore["blockAt"], cfg.explore.blockAt);
+  const verify = section("verify");
+  cfg.verify.enabled = bool(verify["enabled"], cfg.verify.enabled);
+  cfg.verify.blockOnNoEvidence = bool(verify["blockOnNoEvidence"], cfg.verify.blockOnNoEvidence);
+  cfg.verify.evidenceWindowMinutes = num(verify["evidenceWindowMinutes"], cfg.verify.evidenceWindowMinutes);
+  const claims = verify["claimPatterns"];
+  if (Array.isArray(claims)) cfg.verify.claimPatterns = claims.filter((c) => typeof c === "string");
+  const evidence = verify["evidencePatterns"];
+  if (Array.isArray(evidence)) cfg.verify.evidencePatterns = evidence.filter((c) => typeof c === "string");
+  cfg.verify.shellTools = strArr(verify["shellTools"], cfg.verify.shellTools);
+  const legacyShellTools = strArrOrNull(verify["shellTools"]);
+  if (legacyShellTools && !toolsShell) cfg.tools.shell = legacyShellTools;
+  const veto = verify["veto"];
+  if (veto) {
+    cfg.verify.veto.enabled = bool(veto["enabled"], cfg.verify.veto.enabled);
+    cfg.verify.veto.model = typeof veto["model"] === "string" ? veto["model"] : cfg.verify.veto.model;
+    cfg.verify.veto.baseUrl = typeof veto["baseUrl"] === "string" ? veto["baseUrl"] : cfg.verify.veto.baseUrl;
+    cfg.verify.veto.maxCallsPerSession = num(veto["maxCallsPerSession"], cfg.verify.veto.maxCallsPerSession);
+    cfg.verify.veto.timeoutMs = num(veto["timeoutMs"], cfg.verify.veto.timeoutMs);
+  }
+  const thinking = section("thinking");
+  cfg.thinking.enabled = bool(thinking["enabled"], cfg.thinking.enabled);
+  cfg.thinking.minThinkChars = num(thinking["minThinkChars"], cfg.thinking.minThinkChars);
+  cfg.thinking.maxTextRatio = num(thinking["maxTextRatio"], cfg.thinking.maxTextRatio);
+  const anchor = section("anchor");
+  cfg.anchor.enabled = bool(anchor["enabled"], cfg.anchor.enabled);
+  cfg.anchor.everyNPrompts = num(anchor["everyNPrompts"], cfg.anchor.everyNPrompts);
+  cfg.anchor.maxChars = num(anchor["maxChars"], cfg.anchor.maxChars);
+  const context = section("context");
+  cfg.context.enabled = bool(context["enabled"], cfg.context.enabled);
+  cfg.context.warnPercent = num(context["warnPercent"], cfg.context.warnPercent);
+  const noGain = section("noGain");
+  cfg.noGain.enabled = bool(noGain["enabled"], cfg.noGain.enabled);
+  cfg.noGain.windowMinutes = num(noGain["windowMinutes"], cfg.noGain.windowMinutes);
+  cfg.noGain.warnAt = num(noGain["warnAt"], cfg.noGain.warnAt);
+  cfg.noGain.blockAt = num(noGain["blockAt"], cfg.noGain.blockAt);
+  const churn = section("churn");
+  cfg.churn.enabled = bool(churn["enabled"], cfg.churn.enabled);
+  cfg.churn.windowMinutes = num(churn["windowMinutes"], cfg.churn.windowMinutes);
+  cfg.churn.warnAt = num(churn["warnAt"], cfg.churn.warnAt);
+  cfg.churn.blockAt = num(churn["blockAt"], cfg.churn.blockAt);
+  cfg.churn.tools = strArr(churn["tools"], cfg.churn.tools);
+  const legacyChurnTools = strArrOrNull(churn["tools"]);
+  if (legacyChurnTools && !toolsEdit) cfg.tools.edit = legacyChurnTools;
+  const policy = section("policy");
+  cfg.policy.killSwitch = bool(policy["killSwitch"], cfg.policy.killSwitch);
+  cfg.policy.maxBlocksPerSession = num(policy["maxBlocksPerSession"], cfg.policy.maxBlocksPerSession);
+  cfg.policy.blockWindowMinutes = num(policy["blockWindowMinutes"], cfg.policy.blockWindowMinutes);
+  const budget = section("budget");
+  cfg.budget.enabled = bool(budget["enabled"], cfg.budget.enabled);
+  cfg.budget.plan = typeof budget["plan"] === "string" ? budget["plan"] : cfg.budget.plan;
+  cfg.budget.weekly = num(budget["weekly"], cfg.budget.weekly);
+  cfg.budget.fiveHour = num(budget["fiveHour"], cfg.budget.fiveHour);
+  cfg.budget.dispatchTools = strArr(budget["dispatchTools"], cfg.budget.dispatchTools);
+  cfg.budget.reservePercent = num(budget["reservePercent"], cfg.budget.reservePercent);
+  cfg.budget.subagentWeight = num(budget["subagentWeight"], cfg.budget.subagentWeight);
+  cfg.budget.warnPercent = num(budget["warnPercent"], cfg.budget.warnPercent);
+  cfg.budget.precise = bool(budget["precise"], cfg.budget.precise);
+  cfg.budget.preciseUrl = typeof budget["preciseUrl"] === "string" ? budget["preciseUrl"] : cfg.budget.preciseUrl;
+  cfg.budget.preciseCacheSeconds = num(budget["preciseCacheSeconds"], cfg.budget.preciseCacheSeconds);
+  cfg.probe = bool(section("probe")["enabled"], cfg.probe);
+  cfg.verify.shellTools = cfg.tools.shell;
+  cfg.churn.tools = cfg.tools.edit;
+  return cfg;
+}
+function writeConfigTemplate(configPath = userConfigPath()) {
+  if (fs2.existsSync(configPath)) return false;
+  fs2.mkdirSync(configPath.replace(/[/\\][^/\\]+$/, ""), { recursive: true });
+  fs2.writeFileSync(configPath, CONFIG_TEMPLATE, "utf8");
+  return true;
+}
+
+// src/installer.ts
+import fs3 from "fs";
+import path2 from "path";
+var MANAGED_BEGIN = "# >>> kimi-guard managed >>> DO NOT EDIT";
+var MANAGED_END = "# <<< kimi-guard <<<";
+function hookRules(commandName = "kguard", compat = false) {
+  const c = (event) => `${commandName} hook ${event}`;
+  const base = [
+    { event: "PreToolUse", command: c("PreToolUse"), timeout: 5 },
+    { event: "PostToolUse", command: c("PostToolUse"), timeout: 5 },
+    { event: "PostToolUseFailure", command: c("PostToolUseFailure"), timeout: 5 }
+  ];
+  if (compat) return base;
+  return [
+    ...base,
+    { event: "Stop", command: c("Stop"), timeout: 5 },
+    { event: "TurnStarted", command: c("TurnStarted"), timeout: 5 },
+    { event: "SubagentStart", command: c("SubagentStart"), timeout: 5 },
+    { event: "StopFailure", command: c("StopFailure"), timeout: 5 },
+    { event: "Interrupt", command: c("Interrupt"), timeout: 5 },
+    { event: "SessionEnd", command: c("SessionEnd"), timeout: 5 },
+    { event: "PreCompact", command: c("PreCompact"), timeout: 5 },
+    { event: "PostCompact", command: c("PostCompact"), timeout: 5 }
+  ];
+}
+function tomlStr(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function hookToToml(h) {
+  const lines = ["[[hooks]]", `event = "${tomlStr(h.event)}"`, `command = "${tomlStr(h.command)}"`];
+  if (h.matcher) lines.push(`matcher = "${tomlStr(h.matcher)}"`);
+  lines.push(`timeout = ${h.timeout}`);
+  return lines.join("\n");
+}
+function managedBlock(commandName = "kguard", compat = false) {
+  return [MANAGED_BEGIN, ...hookRules(commandName, compat).map(hookToToml), MANAGED_END].join("\n");
+}
+function findManagedBlock(text) {
+  const begin = text.indexOf(MANAGED_BEGIN);
+  if (begin < 0) return void 0;
+  const end = text.indexOf(MANAGED_END, begin);
+  if (end < 0) return void 0;
+  return { start: begin, end: end + MANAGED_END.length };
+}
+function installHooks(commandName = "kguard", compat = false) {
+  const { path: configPath, exists } = detectKimiConfig();
+  const created = !exists;
+  let text = exists ? fs3.readFileSync(configPath, "utf8") : "";
+  const block = findManagedBlock(text);
+  const replaced = block !== void 0;
+  if (exists && !replaced) {
+    const backupPath = `${configPath}.kimi-guard.bak`;
+    fs3.writeFileSync(backupPath, text, "utf8");
+  }
+  const newBlock = managedBlock(commandName, compat);
+  if (block) {
+    text = text.slice(0, block.start) + newBlock + text.slice(block.end);
+  } else {
+    const prefix = text.length === 0 ? "" : text.endsWith("\n") ? "\n" : "\n\n";
+    text = text + prefix + newBlock + "\n";
+  }
+  fs3.mkdirSync(path2.dirname(configPath), { recursive: true });
+  fs3.writeFileSync(configPath, text, "utf8");
+  return {
+    configPath,
+    created,
+    replaced,
+    backupPath: exists && !replaced ? `${configPath}.kimi-guard.bak` : void 0
+  };
+}
+function uninstallHooks() {
+  const { path: configPath, exists } = detectKimiConfig();
+  if (!exists) return { configPath, removed: false };
+  const text = fs3.readFileSync(configPath, "utf8");
+  const block = findManagedBlock(text);
+  if (!block) return { configPath, removed: false };
+  let out = text.slice(0, block.start) + text.slice(block.end);
+  out = out.replace(/^\n{2,}/, "\n");
+  fs3.writeFileSync(configPath, out, "utf8");
+  return { configPath, removed: true };
+}
+function hooksInstalled(configPath) {
+  const p = configPath ?? detectKimiConfig().path;
+  try {
+    return fs3.readFileSync(p, "utf8").includes(MANAGED_BEGIN);
+  } catch {
+    return false;
+  }
+}
+
+// src/harness/claude.ts
+import fs4 from "fs";
+import path3 from "path";
+var CLAUDE_COMMAND_MARKER = "agentguard hook";
+var CLAUDE_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "UserPromptSubmit",
+  "Stop",
+  "SubagentStart",
+  "SessionStart",
+  "SessionEnd",
+  "PreCompact",
+  "PostCompact",
+  "StopFailure"
+];
+var CLAUDE_EVENTS_COMPAT = ["PreToolUse", "PostToolUse", "PostToolUseFailure"];
+function isOurs(group) {
+  return (group.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(CLAUDE_COMMAND_MARKER));
+}
+function ourGroup(event, bin) {
+  return {
+    matcher: "",
+    hooks: [{ type: "command", command: `${bin} hook ${event} --harness claude`, timeout: 5 }]
+  };
+}
+function installClaudeHooks(bin = "agentguard", compat = false) {
+  const configPath = claudeSettingsPath();
+  const created = !fs4.existsSync(configPath);
+  let settings = {};
+  let backupPath;
+  if (!created) {
+    const raw = fs4.readFileSync(configPath, "utf8");
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      backupPath = `${configPath}.agentguard.bak`;
+      fs4.copyFileSync(configPath, backupPath);
+      settings = {};
+    }
+    if (!backupPath) {
+      backupPath = `${configPath}.agentguard.bak`;
+      fs4.writeFileSync(backupPath, raw, "utf8");
+    }
+  }
+  const events = compat ? CLAUDE_EVENTS_COMPAT : CLAUDE_EVENTS;
+  const hooks = settings.hooks ??= {};
+  let updated = false;
+  for (const event of events) {
+    const groups = (hooks[event] ?? []).filter((g) => !isOurs(g));
+    const before = JSON.stringify(hooks[event] ?? []);
+    groups.push(ourGroup(event, bin));
+    hooks[event] = groups;
+    if (JSON.stringify(groups) !== before) updated = true;
+  }
+  fs4.mkdirSync(path3.dirname(configPath), { recursive: true });
+  fs4.writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return { configPath, created, updated: updated || created, backupPath: created ? void 0 : backupPath };
+}
+function uninstallClaudeHooks() {
+  const configPath = claudeSettingsPath();
+  if (!fs4.existsSync(configPath)) return { configPath, removed: false };
+  let settings;
+  try {
+    settings = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+  } catch {
+    return { configPath, removed: false };
+  }
+  const hooks = settings.hooks;
+  if (!hooks) return { configPath, removed: false };
+  let removed = false;
+  for (const event of Object.keys(hooks)) {
+    const kept = hooks[event].filter((g) => !isOurs(g));
+    if (kept.length !== hooks[event].length) removed = true;
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+  }
+  if (removed) fs4.writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return { configPath, removed };
+}
+function claudeHooksInstalled(configPath = claudeSettingsPath()) {
+  try {
+    const settings = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+    return Object.values(settings.hooks ?? {}).some((groups) => groups.some(isOurs));
+  } catch {
+    return false;
+  }
+}
+
+// src/guard.ts
+import fs7 from "fs";
+
+// src/store.ts
+import fs5 from "fs";
+import path4 from "path";
+import { createRequire as createRequire2 } from "module";
+var nodeRequire = createRequire2(import.meta.url);
+function sqliteCtor() {
+  return nodeRequire("node:sqlite").DatabaseSync;
+}
+var SCHEMA_VERSION = 3;
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS calls (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  args_hash TEXT NOT NULL,
+  args_json TEXT NOT NULL,
+  output_hash TEXT,
+  file_path TEXT,
+  status TEXT NOT NULL,
+  ts INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_calls_session ON calls(session_id, ts);
+CREATE INDEX IF NOT EXISTS idx_calls_sig ON calls(session_id, tool_name, args_hash, ts);
+CREATE INDEX IF NOT EXISTS idx_calls_out ON calls(session_id, tool_name, output_hash, ts);
+CREATE INDEX IF NOT EXISTS idx_calls_time ON calls(ts);
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  meta_json TEXT NOT NULL,
+  ts INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_events_kind ON events(session_id, kind, ts);
+CREATE INDEX IF NOT EXISTS idx_events_time ON events(ts);
+CREATE TABLE IF NOT EXISTS blocks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  ts INTEGER NOT NULL,
+  feedback TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_blocks_session ON blocks(session_id, ts);
+CREATE TABLE IF NOT EXISTS meta (
+  k TEXT PRIMARY KEY,
+  v TEXT NOT NULL
+);
+`;
+var db = null;
+function openDb() {
+  if (db) return db;
+  const file = stateDbPath();
+  fs5.mkdirSync(path4.dirname(file), { recursive: true });
+  const d = new (sqliteCtor())(file);
+  d.exec("PRAGMA journal_mode = WAL;");
+  migrate(d);
+  db = d;
+  return db;
+}
+function migrate(d) {
+  d.exec("CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);");
+  const row = d.prepare("SELECT v FROM meta WHERE k = 'schema_version'").get();
+  const version2 = row ? Number(row.v) : 0;
+  if (version2 === SCHEMA_VERSION) {
+    d.exec(SCHEMA);
+    return;
+  }
+  if (version2 === 2) {
+    d.exec(SCHEMA);
+    try {
+      d.exec("ALTER TABLE blocks ADD COLUMN feedback TEXT");
+    } catch {
+    }
+  } else {
+    d.exec("DROP TABLE IF EXISTS calls; DROP TABLE IF EXISTS events; DROP TABLE IF EXISTS blocks;");
+    d.exec(SCHEMA);
+  }
+  d.prepare(
+    "INSERT INTO meta (k, v) VALUES ('schema_version', ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v"
+  ).run(String(SCHEMA_VERSION));
+}
+function recordCall(call) {
+  openDb().prepare(
+    "INSERT INTO calls (session_id, tool_name, args_hash, args_json, output_hash, file_path, status, ts) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(
+    call.sessionId,
+    call.toolName,
+    call.argsHash,
+    call.argsJson,
+    call.outputHash,
+    call.filePath,
+    call.status,
+    call.ts ?? Date.now()
+  );
+}
+function callsSince(sessionId, sinceTs, limit = 500) {
+  return openDb().prepare(
+    "SELECT tool_name, args_hash, args_json, output_hash, file_path, status, ts FROM calls WHERE session_id = ? AND ts >= ? ORDER BY ts ASC LIMIT ?"
+  ).all(sessionId, sinceTs, limit);
+}
+function recordEvent(sessionId, kind, meta, ts = Date.now()) {
+  openDb().prepare("INSERT INTO events (session_id, kind, meta_json, ts) VALUES (?, ?, ?, ?)").run(sessionId, kind, JSON.stringify(meta), ts);
+}
+function countEvents(sessionId, kinds, sinceTs) {
+  const placeholders = kinds.map(() => "?").join(",");
+  const row = openDb().prepare(
+    `SELECT COUNT(*) AS n FROM events WHERE session_id = ? AND kind IN (${placeholders}) AND ts >= ?`
+  ).get(sessionId, ...kinds, sinceTs);
+  return Number(row?.n ?? 0);
+}
+function oldestEventTs(sessionId, kinds, sinceTs) {
+  const placeholders = kinds.map(() => "?").join(",");
+  const row = openDb().prepare(
+    `SELECT MIN(ts) AS m FROM events WHERE session_id = ? AND kind IN (${placeholders}) AND ts >= ?`
+  ).get(sessionId, ...kinds, sinceTs);
+  return row?.m ?? null;
+}
+function recordBlock(sessionId, toolName, kind, ts = Date.now()) {
+  const info = openDb().prepare("INSERT INTO blocks (session_id, tool_name, kind, ts) VALUES (?, ?, ?, ?)").run(sessionId, toolName, kind, ts);
+  return Number(info.lastInsertRowid);
+}
+function listBlocks(limit = 20) {
+  return openDb().prepare("SELECT id, session_id, tool_name, kind, ts, feedback FROM blocks ORDER BY id DESC LIMIT ?").all(limit);
+}
+function setBlockFeedback(id, verdict) {
+  const info = openDb().prepare("UPDATE blocks SET feedback = ? WHERE id = ?").run(verdict, id);
+  return Number(info.changes) > 0;
+}
+function blockKindStats() {
+  const rows = openDb().prepare(
+    `SELECT kind, COUNT(*) AS n,
+              SUM(CASE WHEN feedback = 'fp' THEN 1 ELSE 0 END) AS fp,
+              SUM(CASE WHEN feedback = 'tp' THEN 1 ELSE 0 END) AS tp
+       FROM blocks GROUP BY kind ORDER BY n DESC`
+  ).all();
+  return rows.map((r) => ({ kind: r.kind, n: Number(r.n), fp: Number(r.fp), tp: Number(r.tp) }));
+}
+function countBlocks(sessionId, sinceTs) {
+  const row = openDb().prepare("SELECT COUNT(*) AS n FROM blocks WHERE session_id = ? AND ts >= ?").get(sessionId, sinceTs);
+  return Number(row?.n ?? 0);
+}
+function getMeta(key) {
+  const row = openDb().prepare("SELECT v FROM meta WHERE k = ?").get(key);
+  return row?.v;
+}
+function setMeta(key, value) {
+  openDb().prepare("INSERT INTO meta (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v").run(key, value);
+}
+function knownSessions(limit = 5) {
+  return openDb().prepare(
+    `SELECT session_id, MAX(last_ts) AS last_ts, SUM(n) AS n FROM (
+         SELECT session_id, MAX(ts) AS last_ts, COUNT(*) AS n FROM calls GROUP BY session_id
+         UNION ALL
+         SELECT session_id, MAX(ts) AS last_ts, COUNT(*) AS n FROM events GROUP BY session_id
+       ) GROUP BY session_id ORDER BY last_ts DESC LIMIT ?`
+  ).all(limit);
+}
+function buildStatus() {
+  const d = openDb();
+  const now = Date.now();
+  const day = now - 864e5;
+  const calls24h = Number(d.prepare("SELECT COUNT(*) AS n FROM calls WHERE ts >= ?").get(day).n);
+  const blocks24h = d.prepare("SELECT kind, COUNT(*) AS n FROM blocks WHERE ts >= ? GROUP BY kind").all(day).map((r) => ({ kind: r.kind, n: Number(r.n) }));
+  const topRepeated = d.prepare(
+    "SELECT tool_name, args_hash, COUNT(*) AS n FROM calls WHERE ts >= ? GROUP BY session_id, tool_name, args_hash ORDER BY n DESC LIMIT 5"
+  ).all(day).map((r) => ({ tool_name: r.tool_name, args_hash: r.args_hash, n: Number(r.n) }));
+  const noGainPairs = d.prepare(
+    "SELECT tool_name, COUNT(DISTINCT session_id || ':' || output_hash) AS n FROM calls WHERE ts >= ? AND output_hash IS NOT NULL GROUP BY tool_name ORDER BY n DESC LIMIT 5"
+  ).all(day).map((r) => ({ tool_name: r.tool_name, n: Number(r.n) }));
+  const events24h = d.prepare("SELECT kind, COUNT(*) AS n FROM events WHERE ts >= ? GROUP BY kind").all(day).map((r) => ({ kind: r.kind, n: Number(r.n) }));
+  const lastActivity = d.prepare("SELECT MAX(m) AS m FROM (SELECT MAX(ts) AS m FROM calls UNION ALL SELECT MAX(ts) AS m FROM events)").get();
+  return {
+    calls24h,
+    blocks24h,
+    topRepeated,
+    noGainPairs,
+    events24h,
+    lastActivityTs: lastActivity?.m ?? null
+  };
+}
+
+// src/events.ts
+import { createHash } from "crypto";
+function pickString(payload, keys) {
+  for (const k of keys) {
+    const v = payload[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return "";
+}
+function pickField(payload, keys) {
+  for (const k of keys) {
+    if (payload[k] !== void 0) return payload[k];
+  }
+  return void 0;
+}
+function collapseWs(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function sortDeep(value, collapseStrings) {
+  if (Array.isArray(value)) return value.map((x) => sortDeep(x, collapseStrings));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) {
+      out[k] = sortDeep(value[k], collapseStrings);
+    }
+    return out;
+  }
+  if (value === void 0) return null;
+  if (typeof value === "string") return collapseStrings ? collapseWs(value) : value;
+  return value;
+}
+var WHITESPACE_SENSITIVE = /* @__PURE__ */ new Set(["Shell", "Bash", "Grep", "Glob", "FetchURL", "SearchWeb", "ReadFile", "WriteFile", "StrReplaceFile", "Edit", "Write", "MultiEdit"]);
+function fingerprint(tool, args) {
+  let v = args ?? {};
+  if (v === null || typeof v !== "object") v = { value: v ?? null };
+  const normalized = sortDeep(v, !WHITESPACE_SENSITIVE.has(tool));
+  return createHash("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 16);
+}
+function hashOutput(output) {
+  if (output === void 0 || output === null) return null;
+  let s;
+  if (typeof output === "string") s = output;
+  else {
+    try {
+      s = JSON.stringify(sortDeep(output, false));
+    } catch {
+      s = String(output);
+    }
+  }
+  s = collapseWs(s).slice(0, 4096);
+  if (!s) return null;
+  return createHash("sha256").update(s).digest("hex").slice(0, 16);
+}
+var FILE_KEYS = ["file_path", "filePath", "path", "file", "filename", "notebook_path", "target"];
+function extractFile(args) {
+  if (args === null || typeof args !== "object") return null;
+  const obj = args;
+  for (const k of FILE_KEYS) {
+    const v = obj[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return null;
+}
+function normalizeCall(payload, event, ts = Date.now()) {
+  const sessionId = pickString(payload, ["session_id", "sessionId", "session", "sessionID"]) || "unknown";
+  const tool = pickString(payload, ["tool_name", "toolName", "tool"]);
+  if (!tool) return null;
+  const args = pickField(payload, ["tool_input", "toolInput", "input"]) ?? {};
+  const outputKeys = ["tool_output", "toolOutput", "tool_response", "output", "result"];
+  const output = event === "PostToolUse" ? pickField(payload, outputKeys) : event === "PostToolUseFailure" ? pickField(payload, ["error", "error_message", ...outputKeys]) : void 0;
+  const argsJson = JSON.stringify(args).slice(0, 2048);
+  return {
+    sessionId,
+    tool,
+    args,
+    argsHash: fingerprint(tool, args),
+    argsJson,
+    outputHash: output !== void 0 ? hashOutput(output) : null,
+    filePath: extractFile(args),
+    status: event === "PostToolUseFailure" ? "failure" : "ok",
+    ts
+  };
+}
+
+// src/analysis.ts
+var allow = [];
+function isRepeatExempt(proposed, cfg) {
+  if (cfg.repeat.exemptPatterns.length === 0) return false;
+  let text;
+  try {
+    text = JSON.stringify(proposed.args ?? {});
+  } catch {
+    text = String(proposed.args);
+  }
+  for (const p of cfg.repeat.exemptPatterns) {
+    try {
+      if (new RegExp(p).test(text)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function analyzeRepetition(history, proposed, cfg, now) {
+  if (!cfg.repeat.enabled) return allow;
+  const watched = cfg.repeat.watch.includes(proposed.tool) || proposed.tool in cfg.repeat.thresholds;
+  if (!watched) return allow;
+  if (isRepeatExempt(proposed, cfg)) return allow;
+  const threshold = cfg.repeat.thresholds[proposed.tool] ?? cfg.repeat.maxRepeats;
+  const since = now - cfg.repeat.windowMinutes * 6e4;
+  const n = history.filter(
+    (r) => r.tool_name === proposed.tool && r.args_hash === proposed.argsHash && r.ts >= since
+  ).length;
+  if (n >= threshold) {
+    return [
+      {
+        kind: "repeat",
+        severity: "block",
+        tool: proposed.tool,
+        message: `"${proposed.tool}" has already been called ${n} times with identical arguments in the last ${cfg.repeat.windowMinutes} minutes. The previous results are already in context \u2014 use them instead of re-running. If a retry is genuinely required, change the arguments or state why the previous result is insufficient.`,
+        evidence: `signature count=${n}, threshold=${threshold}`
+      }
+    ];
+  }
+  if (cfg.repeat.warnAt > 0 && n >= cfg.repeat.warnAt) {
+    return [
+      {
+        kind: "repeat",
+        severity: "warn",
+        tool: proposed.tool,
+        message: `"${proposed.tool}" has been called ${n} times with identical arguments \u2014 the result is already in context. Identical calls are blocked at ${threshold}; make sure any retry adds new information.`,
+        evidence: `signature count=${n}, warnAt=${cfg.repeat.warnAt}`
+      }
+    ];
+  }
+  return allow;
+}
+function analyzeCycles(history, cfg, now) {
+  if (!cfg.cycle.enabled) return allow;
+  const since = now - cfg.cycle.windowMinutes * 6e4;
+  const recent = history.filter((r) => r.ts >= since).slice(-16).map((r) => `${r.tool_name}:${r.args_hash}`);
+  if (recent.length < 8) return allow;
+  const findings = [];
+  for (let period = 1; period <= 3; period++) {
+    const minReps = period === 1 ? 5 : 3;
+    const needed = period * minReps;
+    const tail = recent.slice(-needed);
+    if (tail.length < needed) continue;
+    const base = tail.slice(0, period);
+    let isCycle = true;
+    for (let i = period; i < tail.length; i++) {
+      if (tail[i] !== base[i % period]) {
+        isCycle = false;
+        break;
+      }
+    }
+    if (isCycle) {
+      const desc = period === 1 ? `the same call (${base[0]})` : `a ${period}-step cycle (${base.map((s) => s.split(":")[0]).join(" \u2192 ")})`;
+      findings.push({
+        kind: "cycle",
+        severity: "block",
+        tool: base[0]?.split(":")[0],
+        message: `Loop detected: the agent has repeated ${desc} ${minReps}+ times in a row without progress. Stop re-running this sequence. Re-read the results already in context, reassess the approach, and either proceed differently or end the turn with a summary.`,
+        evidence: `period=${period}, reps>=${minReps}`
+      });
+      break;
+    }
+  }
+  return findings;
+}
+function analyzeNoGain(history, cfg, now) {
+  if (!cfg.noGain.enabled) return allow;
+  const since = now - cfg.noGain.windowMinutes * 6e4;
+  const byPair = /* @__PURE__ */ new Map();
+  for (const r of history) {
+    if (r.ts < since || !r.output_hash) continue;
+    const key = `${r.tool_name}:${r.output_hash}`;
+    byPair.set(key, (byPair.get(key) ?? 0) + 1);
+  }
+  const findings = [];
+  for (const [key, n] of byPair) {
+    if (n < cfg.noGain.warnAt) continue;
+    const tool = key.split(":")[0];
+    if (n >= cfg.noGain.blockAt) {
+      findings.push({
+        kind: "noGain",
+        severity: "block",
+        tool,
+        message: `No-progress loop: ${tool} returned the exact same output ${n} times despite different arguments. You are not gaining new information. Stop calling ${tool}, analyze the result you already have, change strategy, or report your findings.`,
+        evidence: `tool=${tool} identical_output_count=${n}`
+      });
+    } else {
+      findings.push({
+        kind: "noGain",
+        severity: "warn",
+        tool,
+        message: `${tool} has returned the same output ${n} times \u2014 verify you are not repeating work.`,
+        evidence: `tool=${tool} identical_output_count=${n}`
+      });
+    }
+  }
+  return findings.slice(0, 2);
+}
+function editToolSet(cfg) {
+  return editTools(cfg);
+}
+function analyzeNoProgress(history, proposed, cfg, now) {
+  if (!cfg.noProgress.enabled) return allow;
+  if (editToolSet(cfg).has(proposed.tool)) return allow;
+  const since = now - cfg.noProgress.windowMinutes * 6e4;
+  const tools = editToolSet(cfg);
+  let lastEditTs = -1;
+  for (const r of history) {
+    if (r.ts < since) continue;
+    if (tools.has(r.tool_name) && r.status === "ok") lastEditTs = Math.max(lastEditTs, r.ts);
+  }
+  const stretch = history.filter((r) => r.ts >= since && r.ts > lastEditTs).length;
+  if (stretch < cfg.noProgress.warnAt) return allow;
+  if (stretch >= cfg.noProgress.blockAt) {
+    return [
+      {
+        kind: "noProgress",
+        severity: "block",
+        tool: proposed.tool,
+        message: `No progress: ${stretch} tool calls in the last ${cfg.noProgress.windowMinutes} minutes with no successful file edit landing. You are circling, not converging. Stop, pick the single most valuable next change, make it deliberately, or report what is blocking you.`,
+        evidence: `stretch=${stretch} warnAt=${cfg.noProgress.warnAt} blockAt=${cfg.noProgress.blockAt}`
+      }
+    ];
+  }
+  return [
+    {
+      kind: "noProgress",
+      severity: "warn",
+      tool: proposed.tool,
+      message: `${stretch} calls without a landed edit recently \u2014 make sure the next step actually produces a change.`,
+      evidence: `stretch=${stretch}`
+    }
+  ];
+}
+function analyzeChurn(history, cfg, now) {
+  if (!cfg.churn.enabled) return allow;
+  const since = now - cfg.churn.windowMinutes * 6e4;
+  const tools = editTools(cfg);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const r of history) {
+    if (r.ts < since || !r.file_path || !tools.has(r.tool_name)) continue;
+    byFile.set(r.file_path, (byFile.get(r.file_path) ?? 0) + 1);
+  }
+  const findings = [];
+  for (const [file, n] of byFile) {
+    if (n >= cfg.churn.blockAt) {
+      findings.push({
+        kind: "churn",
+        severity: "block",
+        tool: "edit",
+        message: `Edit churn: ${file} has been modified ${n} times in the last ${cfg.churn.windowMinutes} minutes without converging. Stop editing. Re-read the file and the error output, form an explicit hypothesis about why previous fixes failed, then make a single deliberate change \u2014 or ask the user for help.`,
+        evidence: `file=${file} edits=${n}`
+      });
+    } else if (n >= cfg.churn.warnAt) {
+      findings.push({
+        kind: "churn",
+        severity: "warn",
+        tool: "edit",
+        message: `${file} has been edited ${n} times recently \u2014 step back and verify your approach before editing again.`,
+        evidence: `file=${file} edits=${n}`
+      });
+    }
+  }
+  return findings.sort((a, b) => a.severity === b.severity ? 0 : a.severity === "block" ? -1 : 1).slice(0, 1);
+}
+function analyzeExplore(history, proposed, cfg, now) {
+  if (!cfg.explore.enabled) return allow;
+  const passive = /* @__PURE__ */ new Set([...readTools(cfg), ...searchTools(cfg)]);
+  if (!passive.has(proposed.tool)) return allow;
+  const since = now - cfg.explore.windowMinutes * 6e4;
+  let streak = 0;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const r = history[i];
+    if (r.ts < since || !passive.has(r.tool_name)) break;
+    streak++;
+  }
+  if (streak < cfg.explore.warnAt) return allow;
+  if (streak >= cfg.explore.blockAt) {
+    return [
+      {
+        kind: "explore",
+        severity: "block",
+        tool: proposed.tool,
+        message: `Exploration without implementation: ${streak} consecutive read/search calls with no action in the last ${cfg.explore.windowMinutes} minutes. You have gathered enough \u2014 pick the most valuable thing you learned and act on it (edit, run, or write). If nothing is actionable, summarize what you found and say so.`,
+        evidence: `streak=${streak} blockAt=${cfg.explore.blockAt}`
+      }
+    ];
+  }
+  return [
+    {
+      kind: "explore",
+      severity: "warn",
+      tool: proposed.tool,
+      message: `${streak} consecutive read/search calls \u2014 make sure the next step acts on what you already learned.`,
+      evidence: `streak=${streak}`
+    }
+  ];
+}
+function fuzzyKey(tool, argsJson) {
+  let text = argsJson;
+  try {
+    const obj = JSON.parse(argsJson);
+    const parts = [];
+    for (const v of Object.values(obj)) {
+      if (typeof v === "string") parts.push(v);
+      else if (v !== null && v !== void 0) parts.push(JSON.stringify(v));
+    }
+    if (parts.length > 0) text = parts.join("|");
+  } catch {
+  }
+  return `${tool}:${text.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]/g, "")}`;
+}
+function analyzeNearRepeat(history, cfg, now = Date.now()) {
+  if (!cfg.nearRepeat.enabled) return allow;
+  const since = now - cfg.nearRepeat.windowMinutes * 6e4;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const r of history) {
+    if (r.ts < since) continue;
+    const key = fuzzyKey(r.tool_name, r.args_json);
+    const cur = byKey.get(key) ?? { n: 0, tool: r.tool_name };
+    cur.n++;
+    byKey.set(key, cur);
+  }
+  const findings = [];
+  for (const [, v] of byKey) {
+    if (v.n >= cfg.nearRepeat.blockAt) {
+      findings.push({
+        kind: "nearRepeat",
+        severity: "block",
+        tool: v.tool,
+        message: `Near-duplicate loop: ${v.tool} has been called ${v.n} times with arguments that differ only trivially (punctuation, case, spacing, order). You are not trying anything new. Use the results already in context or change the approach substantially.`,
+        evidence: `fuzzy_count=${v.n} blockAt=${cfg.nearRepeat.blockAt}`
+      });
+    } else if (v.n >= cfg.nearRepeat.warnAt) {
+      findings.push({
+        kind: "nearRepeat",
+        severity: "warn",
+        tool: v.tool,
+        message: `${v.tool} has ${v.n} near-identical calls recently \u2014 verify these calls differ meaningfully.`,
+        evidence: `fuzzy_count=${v.n}`
+      });
+    }
+  }
+  return findings.sort((a, b) => a.severity === b.severity ? 0 : a.severity === "block" ? -1 : 1).slice(0, 1);
+}
+function analyzeCall(history, proposed, cfg, now = Date.now()) {
+  const findings = [
+    ...analyzeRepetition(history, proposed, cfg, now),
+    ...analyzeCycles(history, cfg, now),
+    ...analyzeNoGain(history, cfg, now),
+    ...analyzeChurn(history, cfg, now),
+    ...analyzeNoProgress(history, proposed, cfg, now),
+    ...analyzeNearRepeat(history, cfg, now),
+    ...analyzeExplore(history, proposed, cfg, now)
+  ];
+  const rank = { block: 0, warn: 1 };
+  findings.sort((a, b) => rank[a.severity] - rank[b.severity]);
+  return { findings: findings.slice(0, 2) };
+}
+
+// src/policy.ts
+var KILL_SWITCH_MESSAGE = "[agent-guard] CIRCUIT BREAK: this session has hit the intervention limit. Stop making tool calls immediately. Do not attempt to work around this guard. Summarize what you have learned so far, state what remains blocked and why, and end your turn so the user can review the situation.";
+function isKillSwitchTripped(blocksInSession, cfg) {
+  return cfg.killSwitch && cfg.maxBlocksPerSession > 0 && blocksInSession >= cfg.maxBlocksPerSession;
+}
+function killSwitchDecision() {
+  return { action: "block", blockReason: KILL_SWITCH_MESSAGE };
+}
+function resolveFindings(findings, ctx) {
+  if (isKillSwitchTripped(ctx.blocksInSession, ctx.cfg)) {
+    return killSwitchDecision();
+  }
+  const block = findings.find((f) => f.severity === "block");
+  if (block) {
+    return { action: "block", blockReason: `[agent-guard] Blocked (${block.kind}): ${block.message}` };
+  }
+  const warns = findings.filter((f) => f.severity === "warn");
+  if (warns.length > 0) {
+    const hint = warns.map((f) => `[agent-guard] note (${f.kind}): ${f.message}`).join(" | ");
+    return { action: "warn", contextHint: hint };
+  }
+  return { action: "allow" };
+}
+
+// src/precise.ts
+var DEFAULT_URL = "https://api.kimi.com/coding/v1";
+var FETCH_TIMEOUT_MS = 3e3;
+function preciseKeyConfigured(env = process.env) {
+  return Boolean(env.KIMI_API_KEY?.trim());
+}
+function cachedPreciseUsage(cfg, now = Date.now()) {
+  if (!cfg.precise) return null;
+  try {
+    const raw = getMeta("precise_usage");
+    const ts = Number(getMeta("precise_usage_ts") ?? "0");
+    if (!raw || ts <= 0) return null;
+    if (now - ts > cfg.preciseCacheSeconds * 1e3) return null;
+    const parsed = JSON.parse(raw);
+    return { ...parsed, fetchedAt: ts };
+  } catch {
+    return null;
+  }
+}
+function numOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function pickNum(obj, keys) {
+  for (const k of keys) {
+    const n = numOrNull(obj[k]);
+    if (n !== null) return n;
+  }
+  return null;
+}
+function pickResetMs(obj, now) {
+  for (const k of ["resetTime", "reset_at", "reset_time"]) {
+    const v = obj[k];
+    if (typeof v === "number" && Number.isFinite(v)) return v > 1e12 ? v : v * 1e3;
+    if (typeof v === "string") {
+      const parsed = Date.parse(v);
+      if (!Number.isNaN(parsed)) return parsed;
+    }
+  }
+  const inSeconds = numOrNull(obj["reset_in"]);
+  return inSeconds !== null ? now + inSeconds * 1e3 : null;
+}
+function windowMinutes(item) {
+  const duration = numOrNull(item["duration"]);
+  const unit = String(item["timeUnit"] ?? item["time_unit"] ?? "").toLowerCase();
+  if (duration === null) return null;
+  if (unit.includes("min")) return duration;
+  if (unit.includes("hour") || unit === "h") return duration * 60;
+  if (unit.includes("day") || unit === "d") return duration * 60 * 24;
+  if (unit.includes("week")) return duration * 60 * 24 * 7;
+  return null;
+}
+function toWindow(item, now) {
+  const limit = pickNum(item, ["limit", "limit_amount"]);
+  const usedRaw = pickNum(item, ["used", "used_amount"]);
+  const remaining = pickNum(item, ["remaining"]);
+  const used = usedRaw ?? (limit !== null && remaining !== null ? limit - remaining : null);
+  if (limit === null || used === null) return null;
+  return { used, limit, resetsAt: pickResetMs(item, now) };
+}
+function parseUsagePayload(payload, now = Date.now()) {
+  if (payload === null || typeof payload !== "object") return null;
+  const root = payload;
+  const items = [];
+  const push = (v) => {
+    if (Array.isArray(v)) {
+      for (const it of v) if (it !== null && typeof it === "object") items.push(it);
+    } else if (v !== null && typeof v === "object") {
+      items.push(v);
+    }
+  };
+  push(root["data"]);
+  push(root["usage"]);
+  push(root["limits"]);
+  let fiveHour = null;
+  let weekly = null;
+  for (const item of items) {
+    const candidates = [item];
+    if (item["detail"] !== null && typeof item["detail"] === "object") candidates.push(item["detail"]);
+    const isSummary = item["model_name"] === "all" || item["scope"] === "all";
+    for (const c of candidates) {
+      const win = toWindow(c, now);
+      if (!win) continue;
+      const mins = windowMinutes(c);
+      if (mins !== null && Math.abs(mins - 300) <= 5 && !fiveHour) fiveHour = win;
+      else if ((isSummary || mins === null || mins >= 60 * 24) && !weekly) weekly = win;
+    }
+  }
+  if (!fiveHour && !weekly) return null;
+  return { fiveHour, weekly, fetchedAt: now };
+}
+async function refreshPreciseUsage(cfg, env = process.env) {
+  if (!cfg.precise || !preciseKeyConfigured(env)) return null;
+  const fresh = cachedPreciseUsage(cfg);
+  if (fresh) return fresh;
+  const base = (cfg.preciseUrl || DEFAULT_URL).replace(/\/+$/, "");
+  const key = env.KIMI_API_KEY.trim();
+  for (const path7 of ["/usages", "/usage"]) {
+    try {
+      const res = await fetch(base + path7, {
+        headers: { Authorization: `Bearer ${key}`, "User-Agent": "KimiCLI/1.6" },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      });
+      if (res.status === 404) continue;
+      if (!res.ok) return null;
+      const parsed = parseUsagePayload(await res.json());
+      if (!parsed) return null;
+      setMeta("precise_usage", JSON.stringify({ fiveHour: parsed.fiveHour, weekly: parsed.weekly }));
+      setMeta("precise_usage_ts", String(parsed.fetchedAt));
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function refreshPreciseIfStale(cfg, env = process.env) {
+  try {
+    if (cfg.precise && !cachedPreciseUsage(cfg)) await refreshPreciseUsage(cfg, env);
+  } catch {
+  }
+}
+
+// src/meter.ts
+var PLANS = {
+  tier1: { weekly: 1024, fiveHour: 200 },
+  tier2: { weekly: 2048, fiveHour: 200 },
+  tier3: { weekly: 7168, fiveHour: 200 }
+};
+var HOUR = 36e5;
+var FIVE_HOURS = 5 * HOUR;
+var WEEK = 7 * 24 * HOUR;
+function resolveLimits(cfg) {
+  const custom = { weekly: cfg.weekly, fiveHour: cfg.fiveHour };
+  if (custom.weekly > 0 || custom.fiveHour > 0) {
+    const preset = PLANS[cfg.plan] ?? { weekly: 0, fiveHour: 0 };
+    return {
+      weekly: custom.weekly > 0 ? custom.weekly : preset.weekly,
+      fiveHour: custom.fiveHour > 0 ? custom.fiveHour : preset.fiveHour
+    };
+  }
+  return PLANS[cfg.plan] ?? { weekly: 0, fiveHour: 0 };
+}
+function budgetSnapshot(sessionId, cfg, now = Date.now()) {
+  const turns = countEvents(sessionId, ["turn"], now - HOUR);
+  const subagents = countEvents(sessionId, ["subagent"], now - HOUR);
+  const used5h = countEvents(sessionId, ["turn"], now - FIVE_HOURS) + countEvents(sessionId, ["subagent"], now - FIVE_HOURS) * cfg.subagentWeight;
+  const usedWeek = countEvents(sessionId, ["turn"], now - WEEK) + countEvents(sessionId, ["subagent"], now - WEEK) * cfg.subagentWeight;
+  const limits = resolveLimits(cfg);
+  const mk = (label, used, limit, span, oldestTs) => ({
+    label,
+    used,
+    limit,
+    percent: limit > 0 ? Math.min(100, Math.round(used / limit * 100)) : 0,
+    resetsInMs: oldestTs !== null ? Math.max(0, oldestTs + span - now) : span
+  });
+  const five = mk("5h", used5h, limits.fiveHour, FIVE_HOURS, oldestEventTs(sessionId, ["turn", "subagent"], now - FIVE_HOURS));
+  const week = mk("weekly", usedWeek, limits.weekly, WEEK, oldestEventTs(sessionId, ["turn", "subagent"], now - WEEK));
+  const precise = cachedPreciseUsage(cfg);
+  if (precise?.fiveHour && precise.fiveHour.limit > 0) {
+    five.used = precise.fiveHour.used;
+    five.limit = precise.fiveHour.limit;
+    five.percent = Math.min(100, Math.round(five.used / five.limit * 100));
+    if (precise.fiveHour.resetsAt !== null) five.resetsInMs = Math.max(0, precise.fiveHour.resetsAt - now);
+  }
+  if (precise?.weekly && precise.weekly.limit > 0) {
+    week.used = precise.weekly.used;
+    week.limit = precise.weekly.limit;
+    week.percent = Math.min(100, Math.round(week.used / week.limit * 100));
+    if (precise.weekly.resetsAt !== null) week.resetsInMs = Math.max(0, precise.weekly.resetsAt - now);
+  }
+  const hoursLeft5h = Math.max(0.25, five.resetsInMs / HOUR);
+  const projected = five.used + turns * hoursLeft5h + subagents * cfg.subagentWeight * hoursLeft5h;
+  return {
+    enabled: cfg.enabled,
+    plan: cfg.plan,
+    fiveHour: five,
+    weekly: week,
+    turnsLastHour: turns,
+    subagentsLastHour: subagents,
+    projectedFiveHour: Math.round(projected),
+    precise: precise !== null
+  };
+}
+function evaluateBudgetGate(sessionId, cfg, now = Date.now()) {
+  if (!cfg.enabled) return null;
+  const snap = budgetSnapshot(sessionId, cfg, now);
+  const reserve = Math.max(0, Math.min(50, cfg.reservePercent));
+  for (const w of [snap.fiveHour, snap.weekly]) {
+    if (w.limit <= 0) continue;
+    if (w.percent >= 100 - reserve) {
+      return {
+        kind: "budget",
+        severity: "block",
+        tool: "dispatch",
+        message: `Quota gate: your ${w.label} request window is ${w.percent}% consumed (${w.used}/${w.limit}) and the guard keeps a ${reserve}% reserve. Do not dispatch subagents \u2014 continue the task directly in this session with minimal tool usage, or ask the user to wait for the window reset or raise [budget] limits.`,
+        evidence: `window=${w.label} used=${w.used} limit=${w.limit}`
+      };
+    }
+  }
+  if (snap.fiveHour.limit > 0 && snap.projectedFiveHour > snap.fiveHour.limit * (1 - reserve / 100)) {
+    return {
+      kind: "budget",
+      severity: "warn",
+      tool: "dispatch",
+      message: `Burn rate warning: at the current rate (~${snap.turnsLastHour} req/h + ${snap.subagentsLastHour} subagent/h) you are projected to reach ~${snap.projectedFiveHour} requests in this 5h window (limit ${snap.fiveHour.limit}). Prefer fewer, larger subagent dispatches.`,
+      evidence: `projected=${snap.projectedFiveHour} limit=${snap.fiveHour.limit}`
+    };
+  }
+  if (snap.fiveHour.percent >= cfg.warnPercent || snap.weekly.percent >= cfg.warnPercent) {
+    return {
+      kind: "budget",
+      severity: "warn",
+      tool: "dispatch",
+      message: `Budget: 5h window ${snap.fiveHour.percent}% used, weekly window ${snap.weekly.percent}% used.`,
+      evidence: `5h=${snap.fiveHour.used}/${snap.fiveHour.limit} week=${snap.weekly.used}/${snap.weekly.limit}`
+    };
+  }
+  return null;
+}
+function formatSnapshot(snap) {
+  if (!snap.enabled) return "budget guard disabled";
+  const bar = (w) => {
+    if (w.limit <= 0) return `${w.used} used (no limit configured)`;
+    const filled = Math.round(w.percent / 100 * 20);
+    return `[${"\u2588".repeat(filled)}${"\u2591".repeat(20 - filled)}] ${w.percent}% (${w.used}/${w.limit})`;
+  };
+  return [
+    `plan: ${snap.plan}${snap.precise ? " (precise, official API)" : ""}`,
+    `5h:     ${bar(snap.fiveHour)}  resets in ${Math.round(snap.fiveHour.resetsInMs / HOUR)}h`,
+    `weekly: ${bar(snap.weekly)}  resets in ${Math.round(snap.weekly.resetsInMs / (24 * HOUR))}d`,
+    `burn rate: ${snap.turnsLastHour} req + ${snap.subagentsLastHour} subagents in the last hour`,
+    `projected 5h usage at current rate: ~${snap.projectedFiveHour}`
+  ].join("\n");
+}
+
+// src/checkpoint.ts
+import fs6 from "fs";
+import path5 from "path";
+function argSummary(argsJson, max = 100) {
+  try {
+    const obj = JSON.parse(argsJson);
+    const parts = [];
+    for (const [k, v] of Object.entries(obj)) {
+      const s = typeof v === "string" ? v : JSON.stringify(v);
+      parts.push(`${k}=${s.length > 60 ? s.slice(0, 57) + "..." : s}`);
+    }
+    const joined = parts.join(", ");
+    return joined.length > max ? joined.slice(0, max - 3) + "..." : joined || "{}";
+  } catch {
+    return argsJson.slice(0, max);
+  }
+}
+function buildBrief(sessionId, now = Date.now(), windowMs = 6 * 36e5, cfg = loadConfig()) {
+  const calls = callsSince(sessionId, now - windowMs, 1e3);
+  if (calls.length === 0) return "";
+  const shells = shellTools(cfg);
+  const edits = editTools(cfg);
+  const reads = readTools(cfg);
+  const searchesSet = searchTools(cfg);
+  const files = /* @__PURE__ */ new Map();
+  const commands = [];
+  const searches = [];
+  const failures = [];
+  for (const r of calls) {
+    const summary = argSummary(r.args_json, 90);
+    if (edits.has(r.tool_name) && r.file_path) {
+      const f = files.get(r.file_path) ?? { reads: 0, edits: 0 };
+      f.edits++;
+      files.set(r.file_path, f);
+    } else if (r.file_path && reads.has(r.tool_name)) {
+      const f = files.get(r.file_path) ?? { reads: 0, edits: 0 };
+      f.reads++;
+      files.set(r.file_path, f);
+    }
+    if (shells.has(r.tool_name)) commands.push(summary);
+    if (searchesSet.has(r.tool_name)) searches.push(summary);
+    if (r.status === "failure") failures.push(`${r.tool_name}: ${summary}`);
+  }
+  const lines = [];
+  lines.push("## Observed activity (auto-captured by agent-guard)");
+  lines.push("");
+  if (files.size > 0) {
+    lines.push("### Files touched");
+    for (const [f, c] of [...files.entries()].slice(0, 25)) {
+      lines.push(`- ${f} (read \xD7${c.reads}, edited \xD7${c.edits})`);
+    }
+    lines.push("");
+  }
+  if (commands.length > 0) {
+    lines.push("### Commands run (most recent last)");
+    for (const c of commands.slice(-10)) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  if (searches.length > 0) {
+    lines.push("### Searches performed (results are already known \u2014 do not redo them)");
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of searches.slice(-15)) {
+      if (seen.has(s)) continue;
+      seen.add(s);
+      lines.push(`- ${s}`);
+    }
+    lines.push("");
+  }
+  if (failures.length > 0) {
+    lines.push("### Failed calls (avoid repeating these)");
+    const seen = /* @__PURE__ */ new Set();
+    for (const f of failures.slice(-8)) {
+      if (seen.has(f)) continue;
+      seen.add(f);
+      lines.push(`- ${f}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Total recorded tool calls in window: ${calls.length}`);
+  return lines.join("\n");
+}
+function captureCheckpoint(sessionId, reason, now = Date.now(), cfg = loadConfig()) {
+  const brief = buildBrief(sessionId, now, 6 * 36e5, cfg);
+  if (!brief) return null;
+  const dir = path5.join(guardHome(), "checkpoints", sessionId.replace(/[^\w.-]/g, "_"));
+  fs6.mkdirSync(dir, { recursive: true });
+  const file = path5.join(dir, `${now}-${reason.replace(/[^\w-]/g, "_")}.md`);
+  const header = [
+    `# agent-guard checkpoint`,
+    ``,
+    `- session: ${sessionId}`,
+    `- time: ${new Date(now).toISOString()}`,
+    `- reason: ${reason}`,
+    ``
+  ].join("\n");
+  fs6.writeFileSync(file, header + brief + "\n", "utf8");
+  recordEvent(sessionId, "checkpoint", { reason, file }, now);
+  return { sessionId, path: file, brief, reason, ts: now };
+}
+function latestSessionId() {
+  const sessions = knownSessions(1);
+  return sessions[0]?.session_id ?? null;
+}
+function latestCheckpointFile(sessionId) {
+  const base = path5.join(guardHome(), "checkpoints");
+  if (!fs6.existsSync(base)) return null;
+  let dir = sessionId ? path5.join(base, sessionId.replace(/[^\w.-]/g, "_")) : "";
+  if (!dir || !fs6.existsSync(dir)) {
+    const dirs = fs6.readdirSync(base).map((d) => ({ d, m: fs6.statSync(path5.join(base, d)).mtimeMs })).sort((a, b) => b.m - a.m);
+    if (dirs.length === 0) return null;
+    dir = path5.join(base, dirs[0].d);
+  }
+  const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().reverse();
+  return files[0] ? path5.join(dir, files[0]) : null;
+}
+function renderResumeBlock(brief, reason) {
+  return [
+    `<agent-guard-resume reason="${reason}">`,
+    "You are resuming a task that was interrupted. Use the observed state below as verified",
+    "prior knowledge. Do NOT re-explore files you have already read, do NOT redo searches",
+    "listed here, and do NOT repeat failed calls. Continue from the last known state.",
+    "",
+    brief,
+    "</agent-guard-resume>"
+  ].join("\n");
+}
+
+// src/verify.ts
+var DEFAULT_CLAIM_PATTERNS = [
+  /\btests?\b.{0,40}\b(pass(?:ed|ing)?|green)\b/i,
+  /\ball\b.{0,24}\btests?\b.{0,24}\bpass/i,
+  /\bbuild\b.{0,30}\b(succeed(?:ed)?|passed|ok)\b/i,
+  /\bcompil(?:es?|ed)\b.{0,20}\bsuccessfully\b/i,
+  /\blint\b.{0,30}\b(clean|passed|no issues)\b/i,
+  /\bfixed\b.{0,40}\b(all|every)\b/i,
+  /测试(全部|都)?通过/,
+  /全部(测试)?通过/,
+  /构建成功/,
+  /编译通过/,
+  /零(错误|警告)/,
+  /问题已全部解决/
+];
+var DEFAULT_EVIDENCE_PATTERNS = [
+  /\b(test|tests|vitest|jest|mocha|pytest|cargo test|go test|make test)\b/i,
+  /\b(npm|pnpm|yarn)\s+(run\s+)?(test|check)\b/i,
+  /\b(mvn|gradle|sbt|dotnet\s+test)\b/i,
+  /\b(tsc|pyright|mypy|eslint|biome|ruff|flake8|clippy)\b/i,
+  /\b(build|compile|lint|check|verify)\b/i,
+  /\bmake\b/i
+];
+function findClaims(text, cfg) {
+  if (!text) return [];
+  const patterns = cfg.verify.claimPatterns.length > 0 ? cfg.verify.claimPatterns.map((p) => new RegExp(p)) : DEFAULT_CLAIM_PATTERNS;
+  const claims = [];
+  for (const p of patterns) {
+    const m = p.exec(text);
+    if (m) {
+      claims.push({
+        pattern: String(p),
+        snippet: text.slice(Math.max(0, (m.index ?? 0) - 40), (m.index ?? 0) + m[0].length + 40).replace(/\s+/g, " ").trim()
+      });
+    }
+    if (claims.length >= 3) break;
+  }
+  return claims;
+}
+function hasEvidence(sessionId, cfg, now = Date.now()) {
+  const vouched = getMeta(`vouched:${sessionId}`) === "1";
+  if (vouched) return true;
+  const since = now - cfg.verify.evidenceWindowMinutes * 6e4;
+  const patterns = cfg.verify.evidencePatterns.length > 0 ? cfg.verify.evidencePatterns.map((p) => new RegExp(p)) : DEFAULT_EVIDENCE_PATTERNS;
+  const shells = shellTools(cfg);
+  const calls = callsSince(sessionId, since, 400);
+  for (const r of calls) {
+    if (r.status !== "ok") continue;
+    if (!shells.has(r.tool_name)) continue;
+    try {
+      const args = JSON.parse(r.args_json);
+      const cmd = args.command ?? "";
+      for (const p of patterns) {
+        if (p.test(cmd)) return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function hasRecentEdits(sessionId, cfg, now = Date.now()) {
+  const since = now - cfg.verify.evidenceWindowMinutes * 6e4;
+  const edits = editTools(cfg);
+  return callsSince(sessionId, since, 400).some(
+    (r) => r.status === "ok" && edits.has(r.tool_name)
+  );
+}
+var HOOKS_STOP_BLOCK_REASON = "[agent-guard] Blocked (verify): this turn ended after successful file edits with no successful verification command (test/build/lint) in the session. Run your verification before claiming completion, or state explicitly why it cannot run here.";
+var WIRE_VERIFY_CORRECTIVE = "[agent-guard verification] Your final message claims tests/build pass, but no successful verification command was recorded in this session. Actually run the verification now and base your claims on real results, then restate the conclusion.";
+
+// src/guard.ts
+function probeEnabled() {
+  if (process.env.KIMI_GUARD_PROBE === "1") return true;
+  try {
+    return getMeta("probe_enabled") === "1";
+  } catch {
+    return false;
+  }
+}
+function appendProbe(event, payload) {
+  const line = JSON.stringify({ ts: Date.now(), event, payload }) + "\n";
+  fs7.appendFileSync(probeLogPath(), line, "utf8");
+}
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : { value: parsed };
+  } catch {
+    return { _unparsed: raw.slice(0, 4096) };
+  }
+}
+function processHookEvent(event, cfg, payload, now = Date.now()) {
+  if (probeEnabled()) {
+    try {
+      appendProbe(event, payload);
+    } catch {
+    }
+  }
+  try {
+    setMeta("last_hook_ts", String(now));
+    setMeta("last_hook_event", event);
+  } catch {
+  }
+  const sessionId = typeof payload["session_id"] === "string" && payload["session_id"] || typeof payload["sessionId"] === "string" && payload["sessionId"] || typeof payload["session"] === "string" && payload["session"] || "unknown";
+  switch (event) {
+    case "PreToolUse":
+      return handlePreToolUse(event, cfg, payload, sessionId, now);
+    case "PostToolUse":
+    case "PostToolUseFailure":
+      return handlePostTool(event, cfg, payload, sessionId, now);
+    case "Stop": {
+      if (cfg.harness === "claude") recordEvent(sessionId, "turn", { origin: "stop" }, now);
+      if (!cfg.verify.enabled || !cfg.verify.blockOnNoEvidence) return { code: 0 };
+      if (!hasRecentEdits(sessionId, cfg, now)) return { code: 0 };
+      if (hasEvidence(sessionId, cfg, now)) return { code: 0 };
+      const id = recordBlock(sessionId, "Stop", "verify", now);
+      return { code: 2, stderr: HOOKS_STOP_BLOCK_REASON + feedbackHint(id) };
+    }
+    case "UserPromptSubmit": {
+      return handleGoalAnchor(payload, sessionId, cfg, now);
+    }
+    case "PreCompact":
+      recordEvent(sessionId, "compaction", { phase: "pre" }, now);
+      setSessionMeta(sessionId, "last_compact_ts", String(now));
+      captureCheckpoint(sessionId, "pre-compact", now, cfg);
+      return { code: 0 };
+    case "PostCompact":
+      recordEvent(sessionId, "compaction", { phase: "post" }, now);
+      return { code: 0 };
+    case "TurnStarted":
+      recordEvent(sessionId, "turn", { origin: payload["origin_kind"] ?? payload["origin"] ?? "" }, now);
+      return { code: 0 };
+    case "SubagentStart":
+      recordEvent(sessionId, "subagent", { agent: payload["agent_name"] ?? "" }, now);
+      return { code: 0 };
+    case "StopFailure":
+      recordEvent(sessionId, "stop_failure", { error: String(payload["error_message"] ?? payload["error_type"] ?? "") }, now);
+      captureCheckpoint(sessionId, "stop-failure", now, cfg);
+      return { code: 0 };
+    case "Interrupt":
+      recordEvent(sessionId, "interrupt", { reason: String(payload["reason"] ?? "") }, now);
+      captureCheckpoint(sessionId, "interrupt", now, cfg);
+      return { code: 0 };
+    case "SessionEnd":
+      captureCheckpoint(sessionId, "session-end", now, cfg);
+      return { code: 0 };
+    default:
+      return { code: 0 };
+  }
+}
+function feedbackHint(id) {
+  return `
+[agent-guard] block #${id} recorded. If this was a false positive, run: kguard feedback fp ${id}`;
+}
+function noteNormalizeMiss(now) {
+  try {
+    const misses = Number(getMeta("normalize_misses") ?? "0") + 1;
+    setMeta("normalize_misses", String(misses));
+    setMeta("last_normalize_miss_ts", String(now));
+  } catch {
+  }
+}
+function handlePreToolUse(event, cfg, payload, sessionId, now) {
+  const call = normalizeCall(payload, event, now);
+  if (!call) {
+    if (Object.keys(payload).length > 0) noteNormalizeMiss(now);
+    return { code: 0 };
+  }
+  const since = now - Math.max(cfg.repeat.windowMinutes, cfg.cycle.windowMinutes, cfg.policy.blockWindowMinutes) * 6e4;
+  const history = callsSince(sessionId, since);
+  const analysis = analyzeCall(history, { tool: call.tool, argsHash: call.argsHash, args: call.args }, cfg, now);
+  if (cfg.budget.dispatchTools.includes(call.tool)) {
+    const budgetFinding = evaluateBudgetGate(sessionId, cfg.budget, now);
+    if (budgetFinding) analysis.findings.unshift(budgetFinding);
+  }
+  const blocksInSession = countBlocks(sessionId, now - cfg.policy.blockWindowMinutes * 6e4);
+  const decision = resolveFindings(analysis.findings, { blocksInSession, cfg: cfg.policy });
+  if (decision.action === "block") {
+    const kind = isKillSwitchTripped(blocksInSession, cfg.policy) ? "killSwitch" : analysis.findings.find((f) => f.severity === "block")?.kind ?? "unknown";
+    const id = recordBlock(sessionId, call.tool, kind, now);
+    return { code: 2, stderr: decision.blockReason + feedbackHint(id) };
+  }
+  if (decision.action === "warn" && decision.contextHint) {
+    return { code: 0, stdout: decision.contextHint };
+  }
+  return { code: 0 };
+}
+function sessionKey(sessionId, key) {
+  return `${key}:${sessionId}`;
+}
+function getSessionMeta(sessionId, key) {
+  return getMeta(sessionKey(sessionId, key));
+}
+function setSessionMeta(sessionId, key, value) {
+  setMeta(sessionKey(sessionId, key), value);
+}
+function handleGoalAnchor(payload, sessionId, cfg, now = Date.now()) {
+  if (!cfg.anchor.enabled) return { code: 0 };
+  const promptText = typeof payload["prompt"] === "string" && payload["prompt"] || typeof payload["user_input"] === "string" && payload["user_input"] || "";
+  if (!promptText) return { code: 0 };
+  const count = Number(getSessionMeta(sessionId, "anchor_count") ?? "0") + 1;
+  setSessionMeta(sessionId, "anchor_count", String(count));
+  recordEvent(sessionId, "prompt", { chars: promptText.length }, now);
+  if (count === 1) {
+    setSessionMeta(sessionId, "goal", promptText.slice(0, cfg.anchor.maxChars));
+    setSessionMeta(sessionId, "last_anchor_ts", String(now));
+    return { code: 0 };
+  }
+  const lastCompact = Number(getSessionMeta(sessionId, "last_compact_ts") ?? "0");
+  const lastAnchor = Number(getSessionMeta(sessionId, "last_anchor_ts") ?? "0");
+  const afterCompaction = lastCompact > lastAnchor;
+  const periodic = count % cfg.anchor.everyNPrompts === 0;
+  if (!afterCompaction && !periodic) return { code: 0 };
+  const goal = getSessionMeta(sessionId, "goal") ?? "";
+  if (!goal) return { code: 0 };
+  setSessionMeta(sessionId, "last_anchor_ts", String(now));
+  return {
+    code: 0,
+    stdout: `[agent-guard] goal anchor (injected ${afterCompaction ? "after compaction" : `every ${cfg.anchor.everyNPrompts} prompts`}): the user's task for this session, verbatim: "${goal}". Re-evaluate: does the current work still serve this goal? If you have drifted, get back on target; if the goal is already met, stop and summarize.`
+  };
+}
+function handlePostTool(event, cfg, payload, sessionId, now) {
+  void cfg;
+  const call = normalizeCall(payload, event, now);
+  if (!call) return { code: 0 };
+  recordCall({
+    sessionId,
+    toolName: call.tool,
+    argsHash: call.argsHash,
+    argsJson: call.argsJson,
+    outputHash: call.outputHash,
+    filePath: call.filePath,
+    status: call.status,
+    ts: now
+  });
+  return { code: 0 };
+}
+
+// src/hook.ts
+function encodeHint(event, harness, text) {
+  if (harness === "claude") {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: text } });
+  }
+  return text;
+}
+async function runHook(event, harness = "kimi") {
+  const payload = await readStdinJson();
+  let outcome;
+  try {
+    const cfg = loadConfig(void 0, harness);
+    if (event === "PreToolUse" && cfg.budget.precise) {
+      const tool = typeof payload["tool_name"] === "string" && payload["tool_name"] || typeof payload["toolName"] === "string" && payload["toolName"] || typeof payload["tool"] === "string" && payload["tool"] || "";
+      if (cfg.budget.dispatchTools.includes(tool)) await refreshPreciseIfStale(cfg.budget);
+    }
+    outcome = processHookEvent(event, cfg, payload);
+  } catch (err) {
+    process.stderr.write(`[agent-guard] guard error (fail-open): ${err.message}
+`);
+    return 0;
+  }
+  if (outcome.stdout) process.stdout.write(encodeHint(event, harness, outcome.stdout) + "\n");
+  if (outcome.stderr) process.stderr.write(outcome.stderr + "\n");
+  return outcome.code;
+}
+
+// src/status.ts
+import fs8 from "fs";
+import { spawnSync } from "child_process";
+import pc from "picocolors";
+
+// src/veto.ts
+function vetoKeyConfigured(env = process.env) {
+  return Boolean(env.KIMI_GUARD_VETO_API_KEY?.trim());
+}
+function vetoBaseUrls(cfg, env = process.env) {
+  return {
+    baseUrl: env.KIMI_GUARD_VETO_BASE_URL?.trim() || cfg.baseUrl,
+    model: env.KIMI_GUARD_VETO_MODEL?.trim() || cfg.model
+  };
+}
+function collectVetoContext(sessionId, cfg, now = Date.now()) {
+  const since = now - cfg.verify.evidenceWindowMinutes * 6e4;
+  const calls = callsSince(sessionId, since, 400);
+  const shells = shellTools(cfg);
+  const recentCommands = [];
+  const editedFiles = [];
+  for (const r of calls.slice(-40)) {
+    if (shells.has(r.tool_name)) {
+      try {
+        const args = JSON.parse(r.args_json);
+        if (args.command) recentCommands.push(args.command.slice(0, 120));
+      } catch {
+      }
+    }
+    if (r.file_path && editedFiles.length < 10) editedFiles.push(r.file_path);
+  }
+  return { sessionId, claims: [], goal: "", recentCommands: recentCommands.slice(-5), editedFiles };
+}
+var PROMPT_HEADER = "You are a false-positive detector for an AI-agent guardrail. An agent just finished its turn claiming completion, but the session's recorded command history contains NO successful verification command (test/build/lint). Decide whether blocking would be a FALSE POSITIVE \u2014 i.e. the agent has a legitimate reason why verification cannot run in this session.\nRules: base your vote ONLY on the facts below. A claim that verification is unnecessary or happens elsewhere is NOT by itself a reason to veto. Answer with EXACTLY one line:\nVETO: yes  (false positive \u2014 allow the completion)\nVETO: no   (block stands \u2014 the agent must actually run verification)\nDo not write anything else.\n\nFacts:\n";
+function buildVetoPrompt(ctx) {
+  const lines = [];
+  lines.push(`- user goal: ${ctx.goal.slice(0, 300) || "(unknown)"}`);
+  lines.push(`- claims made by the agent:`);
+  for (const c of ctx.claims.slice(0, 3)) lines.push(`  "${c.snippet}"`);
+  lines.push(`- recent commands the agent ran: ${ctx.recentCommands.length > 0 ? ctx.recentCommands.join(" ; ") : "(none)"}`);
+  lines.push(`- files the agent edited: ${ctx.editedFiles.length > 0 ? ctx.editedFiles.join(", ") : "(none)"}`);
+  lines.push("- recorded successful verification commands in session history: none");
+  return PROMPT_HEADER + lines.join("\n");
+}
+async function castVetoVote(ctx, cfg, env = process.env) {
+  if (!cfg.enabled || !vetoKeyConfigured(env)) return { vetoed: false, error: "veto disabled" };
+  const calls = Number(getMeta(`veto_calls:${ctx.sessionId}`) ?? "0");
+  if (calls >= cfg.maxCallsPerSession) return { vetoed: false, error: "session vote budget exhausted" };
+  setMeta(`veto_calls:${ctx.sessionId}`, String(calls + 1));
+  const { baseUrl, model } = vetoBaseUrls(cfg, env);
+  const key = env.KIMI_GUARD_VETO_API_KEY.trim();
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: buildVetoPrompt(ctx) }],
+        max_tokens: 8,
+        temperature: 0,
+        stream: false
+      }),
+      signal: AbortSignal.timeout(cfg.timeoutMs)
+    });
+    if (!res.ok) return { vetoed: false, error: `http ${res.status}` };
+    const data = await res.json();
+    const raw = (data.choices?.[0]?.message?.content ?? "").trim();
+    return { vetoed: /^VETO:\s*yes\b/i.test(raw), raw };
+  } catch (err) {
+    return { vetoed: false, error: err.message };
+  }
+}
+
+// src/status.ts
+function ok(msg) {
+  console.log(`${pc.green("\u2713")} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${pc.yellow("!")} ${msg}`);
+}
+function fail(msg) {
+  console.log(`${pc.red("\u2717")} ${msg}`);
+}
+var CALIBRATION_KEYS = {
+  repeat: "repeat.maxRepeats",
+  nearRepeat: "nearRepeat.blockAt",
+  noGain: "noGain.blockAt",
+  churn: "churn.blockAt",
+  noProgress: "noProgress.blockAt",
+  explore: "explore.blockAt",
+  budget: "budget.reservePercent",
+  cycle: "cycle.enabled = false",
+  verify: "verify.blockOnNoEvidence = false (or enable verify.veto)",
+  killSwitch: "policy.maxBlocksPerSession"
+};
+function calibrationHints(stats) {
+  const hints = [];
+  for (const s of stats) {
+    if (s.n < 5) continue;
+    const rate = s.fp / s.n;
+    if (rate > 0.3) {
+      const key = CALIBRATION_KEYS[s.kind] ?? `${s.kind} thresholds`;
+      hints.push(`${s.kind}: ${s.fp}/${s.n} blocks marked false positive (${Math.round(rate * 100)}%) \u2014 consider raising ${key}`);
+    }
+  }
+  return hints;
+}
+function buildGuardReport(cfg = loadConfig()) {
+  const s = buildStatus();
+  const detectors = blockKindStats().map((k) => ({
+    kind: k.kind,
+    blocks: k.n,
+    falsePositives: k.fp,
+    confirmed: k.tp,
+    fpRate: k.n > 0 ? Math.round(k.fp / k.n * 100) / 100 : 0
+  }));
+  const sid = latestSessionId() ?? "unknown";
+  const snap = budgetSnapshot(sid, cfg.budget);
+  return {
+    tool: "agent-guard",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessions: knownSessions(1e3).length,
+    calls24h: s.calls24h,
+    blocks24h: s.blocks24h.reduce((acc, b) => acc + b.n, 0),
+    detectors,
+    budget: {
+      plan: cfg.budget.plan,
+      precise: snap.precise,
+      fiveHourPercent: snap.fiveHour.percent,
+      weeklyPercent: snap.weekly.percent
+    }
+  };
+}
+function agentProcessRunning() {
+  if (process.platform !== "darwin" && process.platform !== "linux") return false;
+  try {
+    const r = spawnSync("ps", ["-eo", "args"], { encoding: "utf8", timeout: 3e3, maxBuffer: 8 * 1024 * 1024 });
+    if (r.status !== 0 || !r.stdout) return false;
+    return r.stdout.split("\n").some((line) => {
+      const l = line.trim();
+      if (l.includes("agentguard") || l.includes("kimi-guard") || l.includes("kguard")) return false;
+      return /(?:^|[/\s])(kimi|claude)(?:\s|$)/.test(l);
+    });
+  } catch {
+    return false;
+  }
+}
+function cmdStatus() {
+  const cfg = loadConfig();
+  const s = buildStatus();
+  const dt = s.lastActivityTs ? new Date(s.lastActivityTs).toISOString() : "never";
+  const lastHookTs = Number(getMeta("last_hook_ts") ?? "0");
+  const lastHook = lastHookTs > 0 ? `${new Date(lastHookTs).toISOString()} (${getMeta("last_hook_event") ?? "?"})` : "never";
+  const normalizeMisses = Number(getMeta("normalize_misses") ?? "0");
+  console.log(`agent-guard status (state: ${stateDbPath()})`);
+  console.log(`  last activity:       ${dt}`);
+  console.log(`  last hook activity:  ${lastHook}`);
+  if (normalizeMisses > 0) {
+    console.log(`  ${pc.yellow("!")} payload normalization misses: ${normalizeMisses} \u2014 possible upstream schema drift; run 'kguard probe on' and compare 'kguard doctor' field coverage`);
+  }
+  console.log(`  tool calls (24h):    ${s.calls24h}`);
+  const parts24 = s.blocks24h.map((b) => `${b.kind}\xD7${b.n}`).join(", ");
+  console.log(`  interventions (24h): ${parts24 || "none"}`);
+  const stats = blockKindStats();
+  const withFeedback = stats.filter((k) => k.fp + k.tp > 0);
+  if (withFeedback.length > 0) {
+    console.log("  intervention quality (all time):");
+    for (const k of stats) {
+      const rate = k.n > 0 ? Math.round(k.fp / k.n * 100) : 0;
+      console.log(`    ${k.kind.padEnd(12)} blocks=${k.n}  fp=${k.fp} (${rate}%)  confirmed=${k.tp}`);
+    }
+    for (const h of calibrationHints(stats)) console.log(`  ${pc.yellow("!")} calibration: ${h}`);
+  }
+  if (s.events24h.length > 0) {
+    console.log(`  agent events (24h):  ${s.events24h.map((e) => `${e.kind}\xD7${e.n}`).join(", ")}`);
+  }
+  const sessions = knownSessions(3);
+  if (sessions.length > 0) {
+    console.log("  recent sessions:");
+    for (const sess of sessions) {
+      console.log(`    ${sess.session_id.slice(0, 24)}  calls=${sess.n}  last=${new Date(sess.last_ts).toISOString()}`);
+    }
+  }
+  if (s.topRepeated.length > 0) {
+    console.log("  top repeated call signatures:");
+    for (const r of s.topRepeated) console.log(`    ${r.tool_name} [${r.args_hash}] \xD7${r.n}`);
+  }
+  console.log("");
+  console.log(`budget (${cfg.budget.plan}):`);
+  const sid = latestSessionId() ?? "unknown";
+  console.log(
+    formatSnapshot(budgetSnapshot(sid, cfg.budget)).split("\n").map((l) => "  " + l).join("\n")
+  );
+}
+function cmdDoctor() {
+  let failures = 0;
+  const cfg = loadConfig();
+  const check = (good, okMsg, failMsg) => {
+    if (good) ok(okMsg);
+    else {
+      fail(failMsg);
+      failures++;
+    }
+  };
+  check(
+    Number(process.versions.node.split(".")[0]) >= 22,
+    `node ${process.versions.node}`,
+    `node ${process.versions.node} is too old (need >=22.13 for node:sqlite)`
+  );
+  try {
+    fs8.mkdirSync(guardHome(), { recursive: true });
+    fs8.accessSync(guardHome(), fs8.constants.W_OK);
+    check(true, `state dir writable: ${guardHome()}`, "");
+    openDb().prepare("SELECT 1").get();
+    check(true, `state db opens (schema v2): ${stateDbPath()}`, "");
+  } catch (err) {
+    check(false, "", `state dir/db problem: ${err.message}`);
+  }
+  const kimi = detectKimiConfig();
+  const hasClaude = claudeDetected();
+  if (kimi.exists || !hasClaude) {
+    check(
+      kimi.exists,
+      `kimi config found: ${kimi.path}`,
+      `kimi config not found (looked at ${kimi.path}); is Kimi Code CLI installed?`
+    );
+    if (kimi.exists) {
+      check(hooksInstalled(kimi.path), "[kimi] hooks managed block present in kimi config", "[kimi] hooks not installed \u2014 run: agentguard install");
+    }
+  } else {
+    console.log(`  ${pc.dim("-")} kimi code not detected (skipped)`);
+  }
+  if (hasClaude) {
+    check(
+      claudeHooksInstalled(),
+      `[claude] hooks present in ${claudeSettingsPath()}`,
+      `[claude] hooks not installed \u2014 run: agentguard install --harness claude`
+    );
+  } else {
+    console.log(`  ${pc.dim("-")} claude code not detected (skipped)`);
+  }
+  const kimiConfigText = fs8.existsSync(kimi.path) ? fs8.readFileSync(kimi.path, "utf8") : "";
+  const hasSecurityLayer = /kimi-boost managed|destructive|secret-guard|branch-guard|block-dangerous/i.test(kimiConfigText);
+  if (hasSecurityLayer) {
+    ok("security-layer hooks detected (authorization axis covered)");
+  } else {
+    warn("no security-layer hooks detected \u2014 agent-guard covers runtime behavior only (authorization axis). Consider kimi-boost presets: npx kimi-boost install");
+  }
+  const which = spawnSync("agentguard", ["--version"], { encoding: "utf8" });
+  check(
+    which.status === 0 || Boolean(process.argv[1]?.includes("agentguard") || process.argv[1]?.includes("kimi-guard")),
+    "agentguard resolves on PATH",
+    "agentguard is not on PATH \u2014 hook commands will fail-open. Install globally: npm i -g @shidesheng0218/agentguard"
+  );
+  const probeFile = probeLogPath();
+  if (fs8.existsSync(probeFile)) {
+    const lines = fs8.readFileSync(probeFile, "utf8").trim().split("\n").filter(Boolean);
+    ok(`probe log has ${lines.length} samples (${probeFile})`);
+    const keys = /* @__PURE__ */ new Map();
+    for (const line of lines.slice(-50)) {
+      try {
+        const p = JSON.parse(line);
+        for (const k of Object.keys(p.payload ?? {})) keys.set(k, (keys.get(k) ?? 0) + 1);
+      } catch {
+      }
+    }
+    if (keys.size > 0) {
+      console.log(`  observed payload keys: ${[...keys.entries()].map(([k, n]) => `${k}(${n})`).join(", ")}`);
+    }
+  } else {
+    warn("no probe samples yet \u2014 run 'kguard probe on', use Kimi Code a bit, then 'kguard doctor'");
+  }
+  if (fs8.existsSync(userConfigPath())) ok(`config present: ${userConfigPath()}`);
+  else warn("no user config (defaults in effect) \u2014 run 'kguard config init' to create one");
+  try {
+    const normalizeMisses = Number(getMeta("normalize_misses") ?? "0");
+    if (normalizeMisses > 0) {
+      const lastMiss = getMeta("last_normalize_miss_ts");
+      warn(
+        `${normalizeMisses} hook payload(s) failed to normalize (last: ${lastMiss ? new Date(Number(lastMiss)).toISOString() : "unknown"}) \u2014 possible upstream schema drift; run 'kguard probe on', use the CLI, then 'kguard probe show'`
+      );
+    } else {
+      ok("hook payload normalization: no misses recorded");
+    }
+    const lastHookTs = Number(getMeta("last_hook_ts") ?? "0");
+    if (hooksInstalled(kimi.path)) {
+      if (lastHookTs === 0) {
+        warn("hooks installed but no hook activity recorded yet \u2014 the guard has never fired in this state db");
+      } else if (Date.now() - lastHookTs > 24 * 36e5 && agentProcessRunning()) {
+        warn(
+          `hooks installed but no hook activity for over 24h while a kimi process is running \u2014 the guard may be silently inert (CLI update? reinstall hooks with 'kguard install')`
+        );
+      } else {
+        ok(`hook activity last seen ${new Date(lastHookTs).toISOString()}`);
+      }
+    }
+  } catch {
+  }
+  if (cfg.verify.veto.enabled) {
+    if (vetoKeyConfigured()) ok(`verify veto: enabled, KIMI_GUARD_VETO_API_KEY present`);
+    else warn("verify veto enabled but KIMI_GUARD_VETO_API_KEY is not set \u2014 the veto is inert at runtime (deterministic gate still works)");
+  } else {
+    ok("verify veto: off (pure deterministic gate)");
+  }
+  if (cfg.budget.precise) {
+    if (preciseKeyConfigured()) ok("budget precise metering: enabled, KIMI_API_KEY present");
+    else warn("budget precise metering enabled but KIMI_API_KEY is not set \u2014 falling back to event-based estimates");
+  }
+  if (failures === 0) console.log("\nAll checks passed.");
+  else console.log(`
+${failures} check(s) failed.`);
+  return failures === 0 ? 0 : 1;
+}
+
+// src/wire/supervisor.ts
+import fs9 from "fs";
+import path6 from "path";
+
+// src/wire/client.ts
+import { spawn } from "child_process";
+import readline from "readline";
+import { randomUUID } from "crypto";
+
+// src/wire/protocol.ts
+var WIRE_PROTOCOL_VERSION = "1.10";
+
+// src/wire/client.ts
+var WireClient = class {
+  proc = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  closed = false;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get running() {
+    return this.proc !== null && this.proc.exitCode === null;
+  }
+  async start() {
+    const command = this.opts.command ?? ["kimi", "--wire"];
+    this.proc = spawn(command[0], command.slice(1), {
+      cwd: this.opts.cwd,
+      env: { ...process.env, ...this.opts.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const rl = readline.createInterface({ input: this.proc.stdout });
+    rl.on("line", (line) => this.handleLine(line));
+    const stderr = readline.createInterface({ input: this.proc.stderr });
+    stderr.on("line", (line) => this.opts.onStderr?.(line));
+    const exited = new Promise((_, reject) => {
+      this.proc.once("exit", (code) => {
+        this.closed = true;
+        for (const p of this.pending.values()) {
+          clearTimeout(p.timer);
+          p.reject(new Error(`wire process exited (code ${code})`));
+        }
+        this.pending.clear();
+        reject(new Error(`wire process exited unexpectedly (code ${code})`));
+      });
+    });
+    exited.catch(() => {
+    });
+    return await this.initialize();
+  }
+  handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    this.opts.onRawLine?.("in", trimmed);
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if ("id" in msg && msg.id !== void 0 && ("result" in msg || "error" in msg)) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      const resp = msg;
+      if (resp.error) pending.reject(new Error(`wire error ${resp.error.code}: ${resp.error.message}`));
+      else pending.resolve(resp.result);
+      return;
+    }
+    if ("method" in msg) {
+      if (msg.method === "event") {
+        const params = msg.params;
+        if (params) this.opts.onEvent?.(params.type, params.payload ?? {});
+        return;
+      }
+      if (msg.method === "request") {
+        void this.handleServerRequest(msg);
+        return;
+      }
+    }
+  }
+  async handleServerRequest(msg) {
+    let result;
+    try {
+      result = await this.opts.onRequest?.(msg.params.type, msg.params.payload) ?? {};
+    } catch (err) {
+      result = { error: err.message };
+    }
+    this.write({ jsonrpc: "2.0", id: msg.id, result });
+  }
+  write(msg) {
+    if (!this.proc?.stdin || this.closed) return;
+    const line = JSON.stringify(msg);
+    this.opts.onRawLine?.("out", line);
+    this.proc.stdin.write(line + "\n");
+  }
+  id() {
+    this.nextId++;
+    return `kguard-${this.nextId}-${randomUUID().slice(0, 8)}`;
+  }
+  async request(method, params, timeoutMs = this.opts.requestTimeoutMs ?? 6e5) {
+    const id = this.id();
+    const promise = new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`wire request timeout: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve: resolve2, reject, timer });
+    });
+    this.write({ jsonrpc: "2.0", method, id, params });
+    return promise;
+  }
+  async initialize() {
+    try {
+      return await this.request(
+        "initialize",
+        {
+          protocol_version: WIRE_PROTOCOL_VERSION,
+          client: { name: "agent-guard", version },
+          capabilities: { supports_question: false },
+          hooks: this.opts.hooks ?? []
+        },
+        3e4
+      );
+    } catch (err) {
+      if (err.message.includes("-32601")) return null;
+      throw err;
+    }
+  }
+  prompt(userInput, timeoutMs) {
+    return this.request("prompt", { user_input: userInput }, timeoutMs);
+  }
+  steer(userInput) {
+    return this.request("steer", { user_input: userInput }, 3e4);
+  }
+  cancel() {
+    return this.request("cancel", {}, 3e4);
+  }
+  stop() {
+    this.closed = true;
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error("client stopped"));
+    }
+    this.pending.clear();
+    this.proc?.kill("SIGTERM");
+    setTimeout(() => this.proc?.kill("SIGKILL"), 3e3).unref();
+  }
+};
+
+// src/wire/supervisor.ts
+var zeroUsage = () => ({ input_other: 0, output: 0, input_cache_read: 0, input_cache_creation: 0 });
+function addUsage(acc, u) {
+  acc.input_other += u.input_other ?? 0;
+  acc.output += u.output ?? 0;
+  acc.input_cache_read += u.input_cache_read ?? 0;
+  acc.input_cache_creation += u.input_cache_creation ?? 0;
+}
+async function runSupervised(opts) {
+  const cfg = opts.config ?? loadConfig();
+  const runId = `run-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`;
+  const logDir = path6.join(guardHome(), "runs", runId);
+  fs9.mkdirSync(logDir, { recursive: true });
+  const logPath = path6.join(logDir, "wire.jsonl");
+  const rawLog = (direction, line) => {
+    try {
+      fs9.appendFileSync(logPath, JSON.stringify({ dir: direction, ts: Date.now(), line }) + "\n");
+    } catch {
+    }
+  };
+  const startedAt = Date.now();
+  const report = {
+    runId,
+    command: opts.command ?? ["kimi", "--wire"],
+    startedAt: new Date(startedAt).toISOString(),
+    finishedAt: "",
+    durationMs: 0,
+    turns: 0,
+    steps: 0,
+    toolCalls: 0,
+    stepRetries: [],
+    blocks: [],
+    steers: [],
+    approvals: { approved: 0, rejected: 0 },
+    tokenUsage: zeroUsage(),
+    finalStatus: "",
+    endReason: "finished",
+    resumes: 0,
+    verifyRounds: 0,
+    vetoes: 0,
+    thinkingDominance: 0,
+    reportPath: path6.join(logDir, "report.json"),
+    logPath
+  };
+  let steersSent = 0;
+  let cancelled = false;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const seenSubagents = /* @__PURE__ */ new Set();
+  const hintedPatterns = /* @__PURE__ */ new Set();
+  const anchoredSteps = /* @__PURE__ */ new Set();
+  let killSwitchArmed = false;
+  let timeoutTimer = null;
+  let turnThinkChars = 0;
+  let turnTextChars = 0;
+  let turnText = "";
+  const client = new WireClient({
+    command: opts.command,
+    cwd: opts.cwd,
+    env: opts.env,
+    onRawLine: rawLog,
+    hooks: [{ id: "kguard", event: "PreToolUse", matcher: "", timeout: 10 }],
+    onEvent: (type, payload) => {
+      void handleEvent(type, payload);
+    },
+    onRequest: (type, payload) => handleRequest(type, payload)
+  });
+  function sessionId() {
+    return runId;
+  }
+  async function steerOnce(kind, message) {
+    if (!opts.steerOnWarn || steersSent >= opts.maxSteers) return;
+    steersSent++;
+    report.steers.push({ kind, message, ts: Date.now() });
+    try {
+      await client.steer(`[agent-guard] ${message}`);
+    } catch {
+    }
+  }
+  function anchorText() {
+    const goal = opts.prompt.slice(0, cfg.anchor.maxChars);
+    return `goal anchor: the user's task for this run, verbatim: "${goal}". Re-evaluate: does the current work still serve this goal? If you have drifted, get back on target; if the goal is already met, stop and summarize.`;
+  }
+  async function handleEvent(type, payload) {
+    switch (type) {
+      case "SubagentEvent": {
+        handleSubagentEvent(payload);
+        break;
+      }
+      case "StepBegin": {
+        const p = payload;
+        report.steps = p.n;
+        recordEvent(sessionId(), "step", { n: p.n });
+        if (cfg.anchor.enabled && opts.steerOnWarn && p.n > 1 && p.n % cfg.anchor.everyNPrompts === 0 && !anchoredSteps.has(p.n)) {
+          anchoredSteps.add(p.n);
+          await steerOnce("anchor", anchorText());
+        }
+        if (p.n > opts.maxSteps && !cancelled) {
+          cancelled = true;
+          report.endReason = "max_steps";
+          void client.cancel().catch(() => {
+          });
+        }
+        break;
+      }
+      case "CompactionEnd": {
+        recordEvent(sessionId(), "compaction", { phase: "wire" });
+        if (cfg.anchor.enabled && opts.steerOnWarn) {
+          await steerOnce("anchor", `context was just compacted. ${anchorText()}`);
+        }
+        break;
+      }
+      case "StepRetry": {
+        const p = payload;
+        report.stepRetries.push({ n: p.n, error_type: p.error_type, status_code: p.status_code ?? null });
+        recordEvent(sessionId(), "step_retry", { error_type: p.error_type, status_code: p.status_code ?? null });
+        break;
+      }
+      case "ContentPart": {
+        const part = payload;
+        if (part.type === "think" && part.think) turnThinkChars += part.think.length;
+        if (part.type === "text" && part.text) {
+          turnTextChars += part.text.length;
+          turnText = (turnText + part.text).slice(-16e3);
+        }
+        break;
+      }
+      case "TurnBegin": {
+        turnThinkChars = 0;
+        turnTextChars = 0;
+        turnText = "";
+        recordEvent(sessionId(), "turn", { wire: true });
+        break;
+      }
+      case "TurnEnd": {
+        if (cfg.thinking.enabled && turnThinkChars >= cfg.thinking.minThinkChars && turnTextChars / (turnThinkChars + turnTextChars) <= cfg.thinking.maxTextRatio) {
+          report.thinkingDominance++;
+          recordEvent(sessionId(), "thinking_dominance", { think_chars: turnThinkChars, text_chars: turnTextChars });
+        }
+        break;
+      }
+      case "StatusUpdate": {
+        const p = payload;
+        if (p.token_usage) addUsage(report.tokenUsage, p.token_usage);
+        if (cfg.context.enabled && typeof p.context_usage === "number" && p.context_usage * 100 >= cfg.context.warnPercent && !hintedPatterns.has("context-fill")) {
+          hintedPatterns.add("context-fill");
+          await steerOnce(
+            "context",
+            `context window is ${Math.round(p.context_usage * 100)}% full. Wrap up the current unit of work, summarize what you have learned, and avoid starting large new explorations \u2014 compaction is imminent.`
+          );
+        }
+        break;
+      }
+      case "ToolCall": {
+        const p = payload;
+        let args = {};
+        try {
+          args = p.function.arguments ? JSON.parse(p.function.arguments) : {};
+        } catch {
+          args = { _raw: p.function.arguments ?? "" };
+        }
+        pendingToolCalls.set(`main:${p.id}`, { name: p.function.name, args });
+        break;
+      }
+      case "ToolResult": {
+        const p = payload;
+        const call = pendingToolCalls.get(`main:${p.tool_call_id}`);
+        if (!call) break;
+        pendingToolCalls.delete(`main:${p.tool_call_id}`);
+        recordObservedCall(sessionId(), call, p.return_value);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  function handleSubagentEvent(p) {
+    const agentKey = p.agent_id ?? p.subagent_type ?? "unknown";
+    if (!seenSubagents.has(agentKey)) {
+      seenSubagents.add(agentKey);
+      recordEvent(sessionId(), "subagent", { agent: agentKey });
+    }
+    const nested = p.event;
+    if (!nested?.type) return;
+    switch (nested.type) {
+      case "ToolCall": {
+        const tp = nested.payload;
+        let args = {};
+        try {
+          args = tp.function.arguments ? JSON.parse(tp.function.arguments) : {};
+        } catch {
+          args = { _raw: tp.function.arguments ?? "" };
+        }
+        pendingToolCalls.set(`sub:${agentKey}:${tp.id}`, { name: tp.function.name, args });
+        break;
+      }
+      case "ToolResult": {
+        const tp = nested.payload;
+        const call = pendingToolCalls.get(`sub:${agentKey}:${tp.tool_call_id}`);
+        if (!call) break;
+        pendingToolCalls.delete(`sub:${agentKey}:${tp.tool_call_id}`);
+        recordObservedCall(`${sessionId()}|sub|${agentKey}`, call, tp.return_value);
+        break;
+      }
+      case "StatusUpdate": {
+        const sp = nested.payload;
+        if (sp.token_usage) addUsage(report.tokenUsage, sp.token_usage);
+        break;
+      }
+      case "StepBegin": {
+        recordEvent(`${sessionId()}|sub|${agentKey}`, "step", { n: nested.payload?.n });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  function recordObservedCall(sessionId2, call, returnValue) {
+    report.toolCalls++;
+    const output = typeof returnValue.output === "string" ? returnValue.output : JSON.stringify(returnValue.output);
+    recordCall({
+      sessionId: sessionId2,
+      toolName: call.name,
+      argsHash: fingerprint(call.name, call.args),
+      argsJson: JSON.stringify(call.args).slice(0, 2048),
+      outputHash: hashOutput(output),
+      filePath: extractFile2(call.args),
+      status: returnValue.is_error ? "failure" : "ok"
+    });
+  }
+  async function handleRequest(type, payload) {
+    switch (type) {
+      case "HookRequest": {
+        const p = payload;
+        return await handleHookRequest(p);
+      }
+      case "ApprovalRequest": {
+        const p = payload;
+        if (opts.approval === "approve") {
+          report.approvals.approved++;
+          return { request_id: p.id, response: "approve" };
+        }
+        report.approvals.rejected++;
+        return {
+          request_id: p.id,
+          response: "reject",
+          feedback: "agent-guard run: interactive approvals are unavailable in supervised headless mode. Continue with non-interactive steps only, or summarize your findings."
+        };
+      }
+      case "QuestionRequest": {
+        const p = payload;
+        return { request_id: p.id, answers: {} };
+      }
+      default:
+        return {};
+    }
+  }
+  async function handleHookRequest(p) {
+    if (killSwitchArmed) {
+      return {
+        request_id: p.id,
+        action: "block",
+        reason: "[agent-guard] CIRCUIT BREAK: this session has hit the intervention limit. Stop making tool calls, summarize your findings, and end the turn."
+      };
+    }
+    if (cancelled) {
+      return { request_id: p.id, action: "allow", reason: "" };
+    }
+    const hookPayload = { ...p.input_data, session_id: sessionId() };
+    const call = hookPayload;
+    const toolName = typeof call.tool_name === "string" ? call.tool_name : p.target;
+    const since = Date.now() - 30 * 6e4;
+    const history = callsSince(sessionId(), since);
+    const args = call.tool_input ?? {};
+    const analysis = analyzeCall(history, { tool: toolName, argsHash: fingerprint(toolName, args), args }, cfg);
+    if (cfg.budget.dispatchTools.includes(toolName)) {
+      await refreshPreciseIfStale(cfg.budget, { ...process.env, ...opts.env });
+      const budgetFinding = evaluateBudgetGate(sessionId(), cfg.budget, Date.now());
+      if (budgetFinding) analysis.findings.unshift(budgetFinding);
+    }
+    const block = analysis.findings.find((f) => f.severity === "block");
+    if (block) {
+      recordBlock(sessionId(), toolName, block.kind);
+      report.blocks.push({ tool: toolName, kind: block.kind, message: block.message, ts: Date.now() });
+      const blocksInSession = countBlocks(sessionId(), Date.now() - cfg.policy.blockWindowMinutes * 6e4);
+      if (cfg.policy.killSwitch && blocksInSession >= cfg.policy.maxBlocksPerSession) {
+        killSwitchArmed = true;
+        report.endReason = "kill-switch";
+        cancelled = true;
+        void client.cancel().catch(() => {
+        });
+      }
+      return { request_id: p.id, action: "block", reason: `[agent-guard] Blocked (${block.kind}): ${block.message}` };
+    }
+    const warn2 = analysis.findings.find((f) => f.severity === "warn");
+    if (warn2) {
+      const key = `${warn2.kind}:${toolName}`;
+      if (!hintedPatterns.has(key)) {
+        hintedPatterns.add(key);
+        await steerOnce(warn2.kind, warn2.message);
+      }
+    }
+    return { request_id: p.id, action: "allow", reason: "" };
+  }
+  try {
+    openDb();
+    await client.start();
+    recordEvent(sessionId(), "run_start", { prompt: opts.prompt.slice(0, 200) });
+    timeoutTimer = setTimeout(() => {
+      if (cancelled) return;
+      cancelled = true;
+      report.endReason = "timeout";
+      void client.cancel().catch(() => {
+      });
+    }, opts.maxMinutes * 6e4);
+    let attempt = 0;
+    let currentPrompt = opts.prompt;
+    while (true) {
+      attempt++;
+      report.turns++;
+      const result = await client.prompt(currentPrompt, opts.maxMinutes * 6e4 + 6e4);
+      report.finalStatus = result.status;
+      if (result.status === "finished") {
+        if (cfg.verify.enabled && report.verifyRounds < opts.maxVerifyRounds) {
+          const claims = findClaims(turnText, cfg);
+          if (claims.length > 0 && !hasEvidence(sessionId(), cfg)) {
+            if (cfg.verify.veto.enabled) {
+              const ctx = {
+                ...collectVetoContext(sessionId(), cfg),
+                claims,
+                goal: opts.prompt
+              };
+              const env = { ...process.env, ...opts.env };
+              const vote = await castVetoVote(ctx, cfg.verify.veto, env);
+              if (vote.vetoed) {
+                report.vetoes++;
+                recordEvent(sessionId(), "veto", { claims: claims.length, raw: vote.raw });
+                break;
+              }
+              if (vote.error) recordEvent(sessionId(), "veto_error", { error: vote.error });
+            }
+            report.verifyRounds++;
+            report.endReason = "verify";
+            recordEvent(sessionId(), "verify_gate", { claims: claims.length });
+            captureCheckpoint(sessionId(), "verify-gate", Date.now(), cfg);
+            currentPrompt = WIRE_VERIFY_CORRECTIVE;
+            continue;
+          }
+        }
+        if (report.endReason === "verify") report.endReason = "finished";
+        break;
+      }
+      if (result.status === "max_steps_reached" && attempt <= opts.autoResume) {
+        report.resumes++;
+        const brief = captureCheckpoint(sessionId(), "auto-resume", Date.now(), cfg);
+        const d6Note = report.thinkingDominance > 0 ? " Note: the previous turns were dominated by thinking with little action \u2014 act more, think less." : "";
+        currentPrompt = (brief ? `You were stopped at the step limit. Observed state so far:
+
+${brief.brief}
+
+` : "") + "You reached the step limit. Continue from where you stopped \u2014 do not repeat work already done." + d6Note;
+        continue;
+      }
+      if (result.status === "cancelled" && report.endReason === "finished") {
+        report.endReason = killSwitchArmed ? "kill-switch" : "timeout";
+      }
+      break;
+    }
+    if (killSwitchArmed) {
+      captureCheckpoint(sessionId(), "kill-switch", Date.now(), cfg);
+    }
+  } catch (err) {
+    report.endReason = "error";
+    const msg = err.message;
+    report.finalStatus = /ENOENT|spawn/i.test(msg) ? `${msg} \u2014 is the agent CLI installed and on PATH? Or pass --exec <command...>` : msg;
+  } finally {
+    if (timeoutTimer) clearTimeout(timeoutTimer);
+    client.stop();
+  }
+  report.durationMs = Date.now() - startedAt;
+  report.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  recordEvent(sessionId(), "run_end", { endReason: report.endReason, blocks: report.blocks.length });
+  try {
+    fs9.writeFileSync(report.reportPath, JSON.stringify(report, null, 2), "utf8");
+  } catch {
+  }
+  return report;
+}
+function extractFile2(args) {
+  if (args === null || typeof args !== "object") return null;
+  const obj = args;
+  for (const k of ["file_path", "filePath", "path", "file", "filename"]) {
+    const v = obj[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return null;
+}
+function formatReport(r) {
+  const dur = Math.round(r.durationMs / 1e3);
+  const lines = [
+    `agent-guard run report`,
+    `  run id:   ${r.runId}`,
+    `  command:  ${r.command.join(" ")}`,
+    `  duration: ${dur}s   steps: ${r.steps}   tool calls: ${r.toolCalls}   turns: ${r.turns}${r.resumes > 0 ? ` (resumed \xD7${r.resumes})` : ""}`,
+    `  end:      ${r.endReason} (last prompt status: ${r.finalStatus})`,
+    `  blocks:   ${r.blocks.length === 0 ? "none" : r.blocks.map((b) => `${b.kind}(${b.tool})`).join(", ")}`,
+    `  steers:   ${r.steers.length === 0 ? "none" : String(r.steers.length)}`,
+    r.verifyRounds > 0 ? `  verify:   ${r.verifyRounds} corrective round(s) for unbacked completion claims` : "",
+    r.vetoes > 0 ? `  veto:     ${r.vetoes} false-positive veto vote(s) accepted the completion` : "",
+    r.thinkingDominance > 0 ? `  thinking: ${r.thinkingDominance} thinking-dominated turn(s) flagged` : "",
+    `  approvals: ${r.approvals.approved} approved, ${r.approvals.rejected} rejected`,
+    `  tokens:   in ${r.tokenUsage.input_other + r.tokenUsage.input_cache_read + r.tokenUsage.input_cache_creation} (cache read ${r.tokenUsage.input_cache_read}) / out ${r.tokenUsage.output}`,
+    r.stepRetries.length > 0 ? `  retries:  ${r.stepRetries.length} (last: ${r.stepRetries[r.stepRetries.length - 1]?.error_type})` : "",
+    `  report:   ${r.reportPath}`,
+    `  wire log: ${r.logPath}`
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("agentguard").description("Runtime behavior guard for coding agents (Kimi Code CLI & Claude Code): loop detection, quota gates, checkpoints").version(version, "-V, --version", "print version");
+program.command("install").description("install hook rules into detected agent CLIs (Kimi Code config.toml and/or Claude Code settings.json)").option("--compat", "legacy-safe mode: only the 3 universally supported hook events (for older kimi-cli versions)").option("--harness <name>", "kimi | claude | all (default: auto-detect installed harnesses, fallback kimi)").action((opts) => {
+  const which = opts.harness ?? "auto";
+  const doKimi = which === "kimi" || which === "all" || which === "auto";
+  const doClaude = which === "claude" || which === "all" || which === "auto" && claudeDetected();
+  if (!doKimi && !doClaude) {
+    console.error(`unknown harness: ${which}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (doKimi) {
+    const r = installHooks("agentguard", Boolean(opts.compat));
+    console.log(`\u2713 [kimi] config: ${r.configPath}${r.created ? " (created)" : ""}`);
+    if (r.backupPath) console.log(`\u2713 [kimi] backup: ${r.backupPath}`);
+    console.log(`\u2713 [kimi] managed hook block ${r.replaced ? "updated" : "added"}${opts.compat ? " (compat)" : ""}`);
+    if (!opts.compat) {
+      console.log("  note: if your CLI fails to load config after this (older kimi-cli), reinstall with: agentguard install --compat");
+    }
+  }
+  if (doClaude) {
+    const r = installClaudeHooks("agentguard", Boolean(opts.compat));
+    console.log(`\u2713 [claude] config: ${r.configPath}${r.created ? " (created)" : ""}`);
+    if (r.backupPath) console.log(`\u2713 [claude] backup: ${r.backupPath}`);
+    console.log(`\u2713 [claude] hooks ${r.updated ? "installed" : "already up to date"}${opts.compat ? " (compat)" : ""}`);
+  }
+  console.log("  restart the agent CLI (or /reload) to take effect.");
+});
+program.command("uninstall").description("remove the managed hook entries from Kimi Code config.toml and Claude Code settings.json").option("--harness <name>", "kimi | claude | all (default: all)").action((opts) => {
+  const which = opts.harness ?? "all";
+  if (which === "kimi" || which === "all") {
+    const r = uninstallHooks();
+    console.log(r.removed ? `\u2713 [kimi] removed managed block from ${r.configPath}` : `[kimi] no managed block found in ${r.configPath}`);
+  }
+  if (which === "claude" || which === "all") {
+    const r = uninstallClaudeHooks();
+    console.log(r.removed ? `\u2713 [claude] removed hooks from ${r.configPath}` : `[claude] no managed hooks found in ${r.configPath}`);
+  }
+});
+program.command("hook").argument("<event>", "hook event name, e.g. PreToolUse").description("hook entrypoint invoked by the agent CLI (reads JSON payload from stdin)").option("--harness <name>", "kimi | claude (default: kimi)", "kimi").action(async (event, opts) => {
+  const harness = opts.harness === "claude" ? "claude" : "kimi";
+  process.exitCode = await runHook(event, harness);
+});
+program.command("status").description("guard activity: calls, interventions, sessions, budget windows").action(() => cmdStatus());
+program.command("doctor").description("verify environment: node, state db, kimi config, PATH, probe samples").action(() => {
+  process.exitCode = cmdDoctor();
+});
+program.command("budget").description("show the quota metering snapshot (windows, burn rate, projection)").option("-s, --session <id>", "session id (defaults to the most recent)").action(async (opts) => {
+  const cfg = loadConfig();
+  if (cfg.budget.precise) {
+    const p = await refreshPreciseUsage(cfg.budget);
+    if (!p) console.error("[agent-guard] precise metering unavailable (missing KIMI_API_KEY or API error) \u2014 showing event-based estimates");
+  }
+  const sid = opts.session ?? latestSessionId() ?? "unknown";
+  console.log(formatSnapshot(budgetSnapshot(sid, cfg.budget)));
+  const limits = resolveLimits(cfg.budget);
+  if (limits.weekly === 0) {
+    console.log(`
+available plans: ${Object.keys(PLANS).join(", ")} \u2014 or set weekly/fiveHour in config`);
+  }
+});
+program.command("checkpoint").description("capture a research-state checkpoint for a session (also auto-captured on failures/interrupts)").option("-s, --session <id>", "session id (defaults to the most recent)").option("-r, --reason <text>", "why the checkpoint is being taken", "manual").action((opts) => {
+  const sid = opts.session ?? latestSessionId();
+  if (!sid) {
+    console.log("no recorded sessions yet");
+    return;
+  }
+  const cp = captureCheckpoint(sid, opts.reason);
+  if (!cp) {
+    console.log("nothing to checkpoint (no recent activity)");
+    return;
+  }
+  console.log(`\u2713 checkpoint saved: ${cp.path}`);
+  console.log(`  resume later with: kguard resume`);
+});
+program.command("resume").description("print a paste-ready context block built from the latest checkpoint").option("-f, --file <path>", "use a specific checkpoint file (defaults to the latest)").action((opts) => {
+  const file = opts.file ?? latestCheckpointFile();
+  if (!file || !fs10.existsSync(file)) {
+    console.log("no checkpoints found \u2014 run 'kguard checkpoint' first");
+    return;
+  }
+  const content = fs10.readFileSync(file, "utf8");
+  const reason = /- reason: (.*)/.exec(content)?.[1] ?? "interrupted";
+  const idx = content.indexOf("## Observed activity");
+  const brief = idx >= 0 ? content.slice(idx) : content;
+  console.log(renderResumeBlock(brief, reason));
+});
+program.command("blocks").description("list recent guard blocks (with ids for feedback)").option("-n, --last <n>", "how many blocks to show", "20").action((opts) => {
+  const rows = listBlocks(Number(opts.last));
+  if (rows.length === 0) {
+    console.log("no blocks recorded yet");
+    return;
+  }
+  for (const r of rows) {
+    const fb = r.feedback ? ` [${r.feedback === "fp" ? "FALSE POSITIVE" : "confirmed"}]` : "";
+    console.log(`#${r.id}  ${new Date(r.ts).toISOString()}  ${r.kind}  ${r.tool_name}  session=${r.session_id.slice(0, 16)}${fb}`);
+  }
+  console.log(`
+mark a false positive: kguard feedback fp <id>   (confirmed: kguard feedback tp <id>)`);
+});
+program.command("feedback").description("mark a block as a false positive (fp) or confirmed (tp) \u2014 feeds detector calibration").argument("<verdict>", "fp | tp").argument("<id>", "block id from 'kguard blocks' or the block message").action((verdict, id) => {
+  if (verdict !== "fp" && verdict !== "tp") {
+    console.error("verdict must be 'fp' (false positive) or 'tp' (confirmed)");
+    process.exitCode = 1;
+    return;
+  }
+  if (setBlockFeedback(Number(id), verdict)) {
+    console.log(`\u2713 block #${id} marked ${verdict === "fp" ? "false positive" : "confirmed"}`);
+  } else {
+    console.error(`no block with id ${id} \u2014 see 'kguard blocks'`);
+    process.exitCode = 1;
+  }
+});
+program.command("report").description("anonymized aggregate of guard activity (no args/paths/commands \u2014 safe to share)").option("--json", "print JSON (default is a text summary)").action((opts) => {
+  const report = buildGuardReport();
+  if (opts.json) {
+    console.log(JSON.stringify({ ...report, version }, null, 2));
+    return;
+  }
+  console.log(`agent-guard report (${report.generatedAt})`);
+  console.log(`  sessions: ${report.sessions}   calls 24h: ${report.calls24h}   blocks 24h: ${report.blocks24h}`);
+  if (report.detectors.length === 0) console.log("  detectors: no blocks recorded");
+  for (const d of report.detectors) {
+    console.log(`  ${d.kind.padEnd(12)} blocks=${d.blocks}  fp=${d.falsePositives} (${Math.round(d.fpRate * 100)}%)  tp=${d.confirmed}`);
+  }
+  console.log(`  budget: ${report.budget.plan}${report.budget.precise ? " (precise)" : ""}  5h=${report.budget.fiveHourPercent}%  weekly=${report.budget.weeklyPercent}%`);
+  console.log("  (aggregate only \u2014 no arguments, paths or commands are included)");
+});
+var probe = program.command("probe").description("capture raw hook payloads for schema discovery");
+probe.command("on").action(() => {
+  setMeta("probe_enabled", "1");
+  console.log(`\u2713 probe on \u2192 ${probeLogPath()}`);
+});
+probe.command("off").action(() => {
+  setMeta("probe_enabled", "0");
+  console.log("\u2713 probe off");
+});
+probe.command("show").option("-n, --last <n>", "how many samples to show", "10").action((opts) => {
+  if (!fs10.existsSync(probeLogPath())) {
+    console.log("no probe samples yet \u2014 run 'kguard probe on' first");
+    return;
+  }
+  const lines = fs10.readFileSync(probeLogPath(), "utf8").trim().split("\n").filter(Boolean);
+  for (const line of lines.slice(-Number(opts.last))) console.log(line);
+});
+var cfgCmd = program.command("config").description("manage the guard config.toml");
+cfgCmd.command("init").description("create the config file with documented defaults").action(() => {
+  console.log(writeConfigTemplate() ? `\u2713 created ${userConfigPath()}` : `already exists: ${userConfigPath()}`);
+});
+cfgCmd.command("path").action(() => {
+  console.log(userConfigPath());
+});
+cfgCmd.command("show").description("print the effective config (file values merged over defaults)").action(() => {
+  console.log(JSON.stringify(loadConfig(), null, 2));
+});
+cfgCmd.command("get <key>").description("print one effective value, e.g. budget.plan or repeat.maxRepeats").action((key) => {
+  const cfg = loadConfig();
+  const value = key.split(".").reduce((acc, k) => acc && typeof acc === "object" ? acc[k] : void 0, cfg);
+  console.log(value === void 0 ? `<unset: ${key}>` : typeof value === "object" ? JSON.stringify(value) : String(value));
+});
+program.command("run").description("supervised headless run: spawns the agent in Wire mode, enforces loop guards, meters tokens, auto-checkpoints").argument("[prompt...]", "task prompt (or use --prompt)").option("-p, --prompt <text>", "task prompt").option("-e, --exec <command...>", "agent command to supervise (default: kimi --wire)").option("--max-steps <n>", "hard step cap (per turn)", "200").option("--max-minutes <n>", "hard wall-clock cap for the whole run", "30").option("--auto-resume <n>", "re-prompt with checkpoint brief after max_steps/kill-switch", "0").option("--max-verify-rounds <n>", "corrective rounds when the final message makes unbacked completion claims", "2").option("--no-steer", "disable soft mid-turn corrections").option("--max-steers <n>", "cap on steer injections", "5").option("--yolo", "auto-approve every approval request").option("--json", "print machine-readable report JSON").action(async (promptParts, opts) => {
+  const prompt = opts.prompt ?? promptParts.join(" ");
+  if (!prompt.trim()) {
+    console.error("error: a prompt is required (argument or --prompt)");
+    process.exit(1);
+  }
+  const report = await runSupervised({
+    prompt,
+    command: opts.exec ?? ["kimi", "--wire"],
+    maxSteps: Number(opts.maxSteps),
+    maxMinutes: Number(opts.maxMinutes),
+    steerOnWarn: opts.steer,
+    maxSteers: Number(opts.maxSteers),
+    autoResume: Number(opts.autoResume),
+    maxVerifyRounds: Number(opts.maxVerifyRounds),
+    approval: opts.yolo ? "approve" : "reject",
+    json: Boolean(opts.json)
+  });
+  if (opts.json) console.log(JSON.stringify(report, null, 2));
+  else console.log(formatReport(report));
+  process.exitCode = report.endReason === "finished" ? 0 : 2;
+});
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`[agent-guard] ${err.message}
+`);
+  process.exit(1);
+});