calllint 1.7.0 → 1.7.2

package/README.md

@@ -64,6 +64,9 @@ will do, it says so and never silently upgrades to `SAFE`.
 - Self-contained HTML report: `calllint scan <config> --html > report.html`
 - Drift / rug-pull detection: `calllint baseline <config>` then `calllint verify <config> --ci`
 - Policy-as-code: `calllint policy init`
+- Continuous Guard: `calllint guard` re-decides the approved authority surface (silent when unchanged); `calllint guard install --host <git|git-pre-push|github|claude-code|copilot|gemini|vscode>` adds a session-start / commit / CI hook that only shells out to `calllint guard` — never a per-call blocker
+- Install the preflight into your hosts: `calllint integrate` prints a reversible install plan (writes nothing); `--apply --approve <digest>` is the only writer and reuses the audited atomic-write-and-rollback engine
+- Claude Code plugin: a `PreToolUse` hook that *recommends* scanning before an agent-tool config edit — advisory, non-blocking, always exits 0, runs no scan itself
 
 CallLint is a heuristic, evidence-backed pre-flight check, **not a proof of
 safety**. `No blockers observed` ≠ guaranteed safe. Full docs, security model,

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { execFileSync } from "node:child_process";
 
 // src/args.ts
@@ -71,11 +71,12 @@ COMMANDS
   inbox inspect <f>     Preflight a normalized agent inbox event
   evidence import <f>   Import a third-party scanner report as evidence (no re-scoring)
   trust prepare <target>  Read-only Trust Gateway preview: resolve to a digest-pinned identity
+  integrate          Install the CallLint preflight server into detected hosts (plan-only; --apply writes)
   diagnostics [target]  Emit editor/agent-host diagnostics JSON (calllint.diagnostics.v0)
   baseline [target]  Record the approved risk surface as a baseline
   approve            Record the repo-wide capability surface as approved state (L4)
   guard              Continuous Guard: re-decide on authority change; silent when unchanged
-  guard install --host <h>  Install a guard hook (git pre-commit, github workflow)
+  guard install --host <h>  Install a guard hook (git, git-pre-push, github, claude-code, copilot, gemini, vscode)
   guard status       Show baseline / disable / installed-hook state
   guard disable      Turn Continuous Guard off (.calllint/guard.json)
   receipt verify <f>    Validate a calllint.receipt.v0 (structure + signature if present)
@@ -127,7 +128,8 @@ VERIFY OPTIONS
   --json             Emit the drift report JSON
 
 GUARD OPTIONS
-  --host <h>         guard install target: git (pre-commit) | github (workflow)
+  --host <h>         guard install target: git | git-pre-push | github | claude-code | copilot | gemini | vscode
+                     (session-start hooks, non-blocking; shared-config hosts print a fragment to merge)
   --approved [file]  Approved baseline to diff against (default: .calllint/approved.json)
   --json             Emit the guard assessment / status JSON
   (exit) silent/note=0, REVIEW=10, UNKNOWN=20, BLOCK=30; guard self-failure is non-zero
@@ -5508,7 +5510,7 @@ function scanOneConfig(text, configPath, policy, args, deps, allowReceipt = true
     if (err2) return { stdout: "", stderr: err2, exitCode: EXIT.ERROR };
   }
   const exitCode = flagBool(args.flags, "ci") ? exitCodeFor(summary, policy) : EXIT.OK;
-  return { stdout, exitCode };
+  return { stdout, exitCode, telemetry: { verdict: summary.verdict } };
 }
 function writeReceiptFile(summary, text, configPath, policy, args, deps) {
   const toolVersion = deps.toolVersion ?? "0.0.0-dev";
@@ -8983,11 +8985,63 @@ function windsurfServerEntry(server) {
   return entry;
 }
 
+// ../../packages/install-planner/src/adapters/claudeDesktop.ts
+var CLAUDE_DESKTOP_HOST_ID = "claude-desktop";
+var CLAUDE_DESKTOP_TIER = "A";
+var claudeDesktopAdapter = {
+  id: CLAUDE_DESKTOP_HOST_ID,
+  tier: CLAUDE_DESKTOP_TIER,
+  createPlan(ctx, upstream) {
+    return buildInstallPlan({ ...ctx, host: CLAUDE_DESKTOP_HOST_ID, tier: CLAUDE_DESKTOP_TIER }, upstream);
+  },
+  validatePlan(plan) {
+    return validatePlan(plan);
+  },
+  applyPlan(plan, ctx) {
+    return applyPlan({
+      plan,
+      approvalDigest: ctx.approvalDigest,
+      configPath: ctx.configPath,
+      backupPath: ctx.backupPath,
+      lockPath: ctx.lockPath,
+      fs: ctx.fs,
+      now: ctx.now
+    });
+  }
+};
+
+// ../../packages/install-planner/src/adapters/vscode.ts
+var VSCODE_HOST_ID = "vscode";
+var VSCODE_TIER = "A";
+var vscodeAdapter = {
+  id: VSCODE_HOST_ID,
+  tier: VSCODE_TIER,
+  createPlan(ctx, upstream) {
+    return buildInstallPlan({ ...ctx, host: VSCODE_HOST_ID, tier: VSCODE_TIER }, upstream);
+  },
+  validatePlan(plan) {
+    return validatePlan(plan);
+  },
+  applyPlan(plan, ctx) {
+    return applyPlan({
+      plan,
+      approvalDigest: ctx.approvalDigest,
+      configPath: ctx.configPath,
+      backupPath: ctx.backupPath,
+      lockPath: ctx.lockPath,
+      fs: ctx.fs,
+      now: ctx.now
+    });
+  }
+};
+
 // ../../packages/install-planner/src/index.ts
 var HOST_ADAPTERS = {
   [claudeCodeAdapter.id]: claudeCodeAdapter,
   [cursorAdapter.id]: cursorAdapter,
-  [windsurfAdapter.id]: windsurfAdapter
+  [windsurfAdapter.id]: windsurfAdapter,
+  [claudeDesktopAdapter.id]: claudeDesktopAdapter,
+  [vscodeAdapter.id]: vscodeAdapter
 };
 function getHostAdapter(host) {
   return HOST_ADAPTERS[host] ?? null;
@@ -9893,7 +9947,15 @@ SEE ALSO
 // src/commands/guard.ts
 import { existsSync as existsSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync11, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname6, join as join17, resolve as resolve10 } from "node:path";
-var GUARD_HOSTS = ["git", "github"];
+var GUARD_HOSTS = [
+  "git",
+  "git-pre-push",
+  "github",
+  "claude-code",
+  "copilot",
+  "gemini",
+  "vscode"
+];
 function guardConfigPath(cwd) {
   return join17(cwd, ".calllint", "guard.json");
 }
@@ -9989,31 +10051,86 @@ function guardRun(args, deps, env) {
 function isGuardHost(v) {
   return v !== void 0 && GUARD_HOSTS.includes(v);
 }
-var GIT_HOOK = `#!/usr/bin/env bash
+var GUARD_CMD = "npx -y calllint guard --no-emoji";
+function gitHookBody(when) {
+  return `#!/usr/bin/env bash
 # CallLint Continuous Guard (ADR 0045). Re-decides the agent-tool authority
-# surface on commit; silent when nothing changed. Generated by \`calllint guard install\`.
+# surface ${when}; silent when nothing changed. Generated by \`calllint guard install\`.
 # CallLint is static and NEVER executes a scanned server.
-npx -y calllint guard --no-emoji
+${GUARD_CMD}
 `;
+}
+var CLAUDE_CODE_HOOK = JSON.stringify(
+  { hooks: { SessionStart: [{ hooks: [{ type: "command", command: GUARD_CMD }] }] } },
+  null,
+  2
+) + "\n";
+var GEMINI_HOOK = JSON.stringify(
+  {
+    hooks: {
+      SessionStart: [
+        { hooks: [{ type: "command", command: GUARD_CMD, name: "calllint-guard" }] }
+      ]
+    }
+  },
+  null,
+  2
+) + "\n";
+var COPILOT_HOOK = JSON.stringify(
+  { version: 1, hooks: { sessionStart: [{ type: "command", command: GUARD_CMD }] } },
+  null,
+  2
+) + "\n";
+var VSCODE_TASK = JSON.stringify(
+  {
+    version: "2.0.0",
+    tasks: [
+      {
+        label: "CallLint Continuous Guard",
+        type: "shell",
+        command: GUARD_CMD,
+        runOptions: { runOn: "folderOpen" },
+        presentation: { reveal: "silent", panel: "shared" },
+        problemMatcher: []
+      }
+    ]
+  },
+  null,
+  2
+) + "\n";
 function guardArtifact(host) {
-  if (host === "git") {
-    return { path: join17(".git", "hooks", "pre-commit"), content: GIT_HOOK, label: "git pre-commit hook" };
+  switch (host) {
+    case "git":
+      return { path: join17(".git", "hooks", "pre-commit"), content: gitHookBody("on commit"), label: "git pre-commit hook", posture: "dedicated" };
+    case "git-pre-push":
+      return { path: join17(".git", "hooks", "pre-push"), content: gitHookBody("on push"), label: "git pre-push hook", posture: "dedicated" };
+    case "github":
+      return { path: join17(".github", "workflows", "calllint.yml"), content: renderCiGate({ mode: "drift" }), label: "GitHub Actions drift-gate workflow", posture: "dedicated" };
+    case "copilot":
+      return { path: join17(".github", "hooks", "calllint.json"), content: COPILOT_HOOK, label: "Copilot CLI sessionStart hook", posture: "dedicated" };
+    case "claude-code":
+      return { path: join17(".claude", "settings.json"), content: CLAUDE_CODE_HOOK, label: "Claude Code SessionStart hook", posture: "shared" };
+    case "gemini":
+      return { path: join17(".gemini", "settings.json"), content: GEMINI_HOOK, label: "Gemini CLI SessionStart hook", posture: "shared" };
+    case "vscode":
+      return { path: join17(".vscode", "tasks.json"), content: VSCODE_TASK, label: "VS Code folderOpen guard task", posture: "shared" };
   }
-  return {
-    path: join17(".github", "workflows", "calllint.yml"),
-    content: renderCiGate({ mode: "drift" }),
-    label: "GitHub Actions drift-gate workflow"
-  };
 }
 function guardInstall(args, deps) {
   const host = flagStr(args.flags, "host");
   if (!host) {
-    const list = GUARD_HOSTS.map((h2) => `  ${h2.padEnd(8)} \u2192 ${guardArtifact(h2).label}`).join("\n");
+    const list = GUARD_HOSTS.map((h2) => {
+      const a = guardArtifact(h2);
+      const tag = a.posture === "shared" ? " (fragment)" : "";
+      return `  ${h2.padEnd(13)} \u2192 ${a.label}${tag}`;
+    }).join("\n");
     return {
       stdout: `Usage: calllint guard install --host <host>
 
 Hosts:
-${list}`,
+${list}
+
+(fragment) hosts live inside a shared config file; install prints a snippet to merge and never overwrites it.`,
       exitCode: EXIT.OK
     };
   }
@@ -10026,7 +10143,39 @@ Run \`calllint guard install\` to list hosts.`,
     };
   }
   const art = guardArtifact(host);
-  const rel = flagStr(args.flags, "out") ?? art.path;
+  const outFlag = flagStr(args.flags, "out");
+  const rel = outFlag ?? art.path;
+  if (art.posture === "shared") {
+    if (outFlag) {
+      const abs2 = resolve10(deps.cwd, rel);
+      if (existsSync12(abs2)) {
+        return {
+          stdout: "",
+          stderr: `Refusing to overwrite ${rel} \u2014 CallLint will not clobber a shared config file.
+Merge this fragment into it instead:
+
+${art.content}`,
+          exitCode: EXIT.USAGE
+        };
+      }
+      if (deps.writeFile === false) {
+        return { stdout: `Would write ${rel} (${art.label})`, exitCode: EXIT.OK };
+      }
+      try {
+        mkdirSync6(dirname6(abs2), { recursive: true });
+        writeFileSync11(abs2, art.content, "utf8");
+      } catch (e) {
+        return { stdout: "", stderr: `Failed to write ${rel}: ${e instanceof Error ? e.message : String(e)}`, exitCode: EXIT.ERROR };
+      }
+      return { stdout: `Wrote ${rel} (${art.label})`, exitCode: EXIT.OK };
+    }
+    return {
+      stdout: `${art.label} \u2014 merge this into ${rel} (a shared config file CallLint will not overwrite):
+
+${art.content}`,
+      exitCode: EXIT.OK
+    };
+  }
   if (deps.writeFile === false) {
     return { stdout: `Would write ${rel} (${art.label})`, exitCode: EXIT.OK };
   }
@@ -10041,7 +10190,7 @@ Run \`calllint guard install\` to list hosts.`,
       exitCode: EXIT.ERROR
     };
   }
-  const note = host === "git" ? `
+  const note = host === "git" || host === "git-pre-push" ? `
 Make it executable: chmod +x ${rel}` : "";
   return { stdout: `Wrote ${rel} (${art.label})${note}`, exitCode: EXIT.OK };
 }
@@ -10049,16 +10198,26 @@ function guardStatus(args, deps, env) {
   const approvedPath = flagStr(args.flags, "approved") ?? defaultApprovedPath(deps.cwd);
   const hasBaseline = existsSync12(approvedPath);
   const disabled = isDisabled(deps.cwd, env);
-  const gitHook = existsSync12(join17(deps.cwd, ".git", "hooks", "pre-commit"));
-  const ghWorkflow = existsSync12(join17(deps.cwd, ".github", "workflows", "calllint.yml"));
+  const HOST_STATUS_KEY = {
+    git: "git:pre-commit",
+    "git-pre-push": "git:pre-push",
+    github: "github:workflow",
+    copilot: "copilot:sessionStart",
+    "claude-code": "claude-code:sessionStart",
+    gemini: "gemini:sessionStart",
+    vscode: "vscode:folderOpen"
+  };
+  const installedHooks = {};
+  for (const host of GUARD_HOSTS) {
+    const art = guardArtifact(host);
+    const abs = join17(deps.cwd, art.path);
+    installedHooks[HOST_STATUS_KEY[host]] = hookInstalled(abs, art.posture);
+  }
   const status = {
     enabled: !disabled,
     disabledBy: disabled ? env["CALLLINT_GUARD"] === "0" ? "env:CALLLINT_GUARD=0" : "flag:.calllint/guard.json" : null,
     approvedBaseline: hasBaseline ? approvedPath : null,
-    installedHooks: {
-      "git:pre-commit": gitHook,
-      "github:workflow": ghWorkflow
-    }
+    installedHooks
   };
   if (flagBool(args.flags, "json")) {
     return { stdout: JSON.stringify(status), exitCode: EXIT.OK };
@@ -10066,11 +10225,21 @@ function guardStatus(args, deps, env) {
   const lines = [
     `Continuous Guard: ${status.enabled ? "enabled" : `disabled (${status.disabledBy})`}`,
     `Approved baseline: ${hasBaseline ? approvedPath : "none \u2014 run `calllint approve`"}`,
-    `git pre-commit hook: ${gitHook ? "installed" : "not installed"}`,
-    `GitHub workflow: ${ghWorkflow ? "installed" : "not installed"}`
+    ...GUARD_HOSTS.map(
+      (h2) => `${HOST_STATUS_KEY[h2]}: ${installedHooks[HOST_STATUS_KEY[h2]] ? "installed" : "not installed"}`
+    )
   ];
   return { stdout: lines.join("\n"), exitCode: EXIT.OK };
 }
+function hookInstalled(abs, posture) {
+  if (!existsSync12(abs)) return false;
+  if (posture === "dedicated") return true;
+  try {
+    return readFileSync19(abs, "utf8").includes("calllint guard");
+  } catch {
+    return false;
+  }
+}
 function guardSetEnabled(deps, enabled) {
   const cfg = { schemaVersion: "calllint.guard-config.v0", enabled };
   if (deps.writeFile === false) {
@@ -10093,8 +10262,477 @@ function guardSetEnabled(deps, enabled) {
   };
 }
 
+// src/commands/integrate.ts
+import { existsSync as existsSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync12, mkdirSync as mkdirSync7 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join18, resolve as resolve11 } from "node:path";
+
+// ../../packages/agent-triggers/src/overlays.ts
+var PLATFORM_OVERLAYS = {
+  "claude-code": {
+    host: "claude-code",
+    displayName: "Claude Code",
+    channels: ["plugin-hook", "cli-recommend"],
+    supportsRuntimeHook: true
+  },
+  cursor: {
+    host: "cursor",
+    displayName: "Cursor",
+    channels: ["cli-recommend", "ide-diagnostic"],
+    supportsRuntimeHook: false
+  },
+  windsurf: {
+    host: "windsurf",
+    displayName: "Windsurf",
+    channels: ["cli-recommend", "ide-diagnostic"],
+    supportsRuntimeHook: false
+  },
+  "claude-desktop": {
+    host: "claude-desktop",
+    displayName: "Claude Desktop",
+    channels: ["cli-recommend"],
+    supportsRuntimeHook: false
+  },
+  vscode: {
+    host: "vscode",
+    displayName: "VS Code",
+    channels: ["cli-recommend", "ide-diagnostic"],
+    supportsRuntimeHook: false
+  }
+};
+function overlayForHost(host) {
+  return PLATFORM_OVERLAYS[host] ?? null;
+}
+
+// src/commands/integrate.ts
+var CALLLINT_MCP_SERVER_NAME = "calllint";
+function calllintMcpEntry() {
+  return { command: "npx", args: ["-y", "calllint-mcp"] };
+}
+function integrableHosts() {
+  return Object.values(HOST_ADAPTERS).filter((a) => typeof a.applyPlan === "function").map((a) => a.id).sort();
+}
+function decideForIntegrate(authority) {
+  const policy = loadPolicyOrDefault();
+  const flows = buildFlows([authority]);
+  const flowReasons = foldFlowsIntoReasons(flows);
+  return decideOverAuthority({ authority, policy, flowReasons });
+}
+function integrateCommand(args, deps) {
+  const sub = args.positionals[0];
+  if (sub === "help") return integrateHelp();
+  if (sub !== void 0) {
+    return usage(`Unexpected argument "${sub}". Run \`calllint integrate help\`.`);
+  }
+  const apply = flagBool(args.flags, "apply");
+  return apply ? integrateApply(args, deps) : integratePlan(args, deps);
+}
+function integratePlan(args, deps) {
+  const only = flagStr(args.flags, "host");
+  const hosts = only ? [only] : integrableHosts();
+  const detected = detectHosts(deps.cwd, hosts);
+  const hostPlans = hosts.map((h2) => planForHost(h2, detected, deps));
+  const written = /* @__PURE__ */ new Map();
+  if (flagBool(args.flags, "write-plan") && deps.write !== false) {
+    for (const hp of hostPlans) {
+      if (hp.plan) written.set(hp.host, writePlanFile2(hp.plan, deps.cwd));
+    }
+  }
+  if (flagBool(args.flags, "json")) {
+    const payload = {
+      schema: "calllint.integrate-plan.v0",
+      generatedAt: deps.generatedAt,
+      hosts: hostPlans.map((hp) => ({
+        host: hp.host,
+        configPath: hp.configPath,
+        planDigest: hp.plan?.planDigest ?? null,
+        operations: hp.plan?.operations.length ?? 0,
+        planFile: written.get(hp.host) ?? null,
+        note: hp.note
+      }))
+    };
+    return { stdout: JSON.stringify(payload, null, 2), stderr: "", exitCode: EXIT.OK };
+  }
+  return { stdout: renderPlans(hostPlans, written), stderr: "", exitCode: EXIT.OK };
+}
+function writePlanFile2(plan, cwd) {
+  const planDir = join18(cwd, ".calllint", "plans");
+  mkdirSync7(planDir, { recursive: true });
+  const file = join18(planDir, `${plan.planId}.json`);
+  writeFileSync12(file, JSON.stringify(plan, null, 2) + "\n", "utf8");
+  return file;
+}
+function detectHosts(cwd, hosts) {
+  const result = discoverConfigs({ cwd, agentTypes: hosts, includeMissing: true });
+  const cwdPrefix = resolve11(cwd);
+  const byHost = /* @__PURE__ */ new Map();
+  for (const d of result.discovered) {
+    if (!resolve11(d.configPath).startsWith(cwdPrefix)) continue;
+    const prior = byHost.get(d.agentType);
+    if (!prior || !prior.exists && d.exists) byHost.set(d.agentType, d);
+  }
+  return byHost;
+}
+function planForHost(host, detected, deps) {
+  const adapter = getHostAdapter(host);
+  const overlay = overlayForHost(host);
+  const discovered = detected.get(host);
+  const configFromDiscovery = discovered?.configPath;
+  const configPath = configFromDiscovery ?? "(no default config path)";
+  if (!adapter || !adapter.applyPlan) {
+    return { host, configPath, plan: null, note: `host "${host}" has no audited writer (plan-only elsewhere)` };
+  }
+  if (!configFromDiscovery || !discovered?.exists) {
+    return { host, configPath, plan: null, note: `host "${host}" not detected on this machine` };
+  }
+  let currentConfig = null;
+  let configDigest = "absent";
+  if (existsSync13(configFromDiscovery)) {
+    try {
+      const bytes = readFileSync20(configFromDiscovery, "utf8");
+      configDigest = hashJson(bytes);
+      currentConfig = JSON.parse(bytes);
+    } catch {
+      return { host, configPath, plan: null, note: `host config exists but is not valid JSON: ${configFromDiscovery}` };
+    }
+  }
+  if (serverAlreadyPresent(currentConfig)) {
+    return { host, configPath, plan: null, note: "already integrated (calllint server present) \u2014 no change" };
+  }
+  const calllintServer = {
+    name: CALLLINT_MCP_SERVER_NAME,
+    sourceConfigPath: configFromDiscovery,
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "calllint-mcp"],
+    envKeys: [],
+    env: {},
+    providedTools: [],
+    raw: calllintMcpEntry()
+  };
+  const authority = buildAuthorityManifest({ artifactDigest: null, servers: [calllintServer], surfaces: [] });
+  const decision = decideForIntegrate(authority);
+  const backupPath = `${configFromDiscovery}.calllint-backup`;
+  const expiresAt = planExpiry2(deps.generatedAt);
+  const ctx = {
+    host,
+    tier: adapter.tier,
+    configPath: configFromDiscovery,
+    configDigest,
+    currentConfig,
+    servers: [{ name: CALLLINT_MCP_SERVER_NAME, entry: calllintMcpEntry() }],
+    backupPath,
+    expiresAt
+  };
+  const plan = adapter.createPlan(ctx, { artifactDigest: null, authority, decision });
+  return { host, configPath, plan, note: null };
+}
+function serverAlreadyPresent(config) {
+  if (!config || typeof config !== "object") return false;
+  const servers = config.mcpServers;
+  if (!servers || typeof servers !== "object") return false;
+  return Object.prototype.hasOwnProperty.call(servers, CALLLINT_MCP_SERVER_NAME);
+}
+function integrateApply(args, deps) {
+  const planFile = flagStr(args.flags, "plan");
+  const approve = flagStr(args.flags, "approve");
+  if (!planFile) return usage("Missing --plan <file>\nUsage: calllint integrate --apply --plan <plan.json> --approve <plan-digest>");
+  if (!approve) return usage("Missing --approve <plan-digest>\nApproval must name the exact plan digest you reviewed.");
+  let plan;
+  try {
+    plan = JSON.parse(readFileSync20(resolve11(deps.cwd, planFile), "utf8"));
+  } catch (err2) {
+    const e = err2;
+    return { stdout: "", stderr: e.code === "ENOENT" ? `Plan file not found: ${planFile}` : `Plan file is not valid JSON: ${e.message}`, exitCode: EXIT.ERROR };
+  }
+  if (plan?.schema !== "calllint.install-plan.v1") {
+    return { stdout: "", stderr: `Not a calllint.install-plan.v1 document: ${planFile}`, exitCode: EXIT.ERROR };
+  }
+  if (!verifyPlanDigest(plan)) {
+    return { stdout: "", stderr: "Plan digest does not match its contents (tampered or hand-edited). Re-run `calllint integrate` to regenerate.", exitCode: EXIT.ERROR };
+  }
+  const adapter = getHostAdapter(plan.host);
+  if (!adapter) return usage(`Unknown host "${plan.host}".`);
+  if (!adapter.applyPlan) return usage(`Host "${plan.host}" is tier ${adapter.tier} \u2014 plan-only; cannot apply.`);
+  const rawTarget = plan.operations[0]?.target;
+  if (!rawTarget) return usage("Plan has no operations to apply.");
+  let configPath;
+  try {
+    configPath = safeConfigPath(rawTarget, { cwd: deps.cwd, home: homedir2() });
+  } catch (err2) {
+    if (err2 instanceof PathSafetyError) return { stdout: "", stderr: `Unsafe target path in plan: ${err2.message}`, exitCode: EXIT.ERROR };
+    throw err2;
+  }
+  const rid = shortReceiptId(plan.planDigest, deps.generatedAt);
+  const backupPath = `${configPath}.calllint-backup-${rid}`;
+  const lockPath = join18(deps.cwd, ".calllint", "locks", `${hashJson(configPath).slice("sha256:".length, "sha256:".length + 16)}.lock`);
+  const result = adapter.applyPlan(plan, {
+    approvalDigest: approve,
+    configPath,
+    backupPath,
+    lockPath,
+    fs: nodeFsPort(),
+    now: deps.generatedAt
+  });
+  if (flagBool(args.flags, "json")) {
+    return { stdout: JSON.stringify(result, null, 2), stderr: "", exitCode: applyExitCode2(result) };
+  }
+  return { stdout: renderApply(result), stderr: "", exitCode: applyExitCode2(result) };
+}
+function planExpiry2(generatedAt) {
+  const ms = Date.parse(generatedAt);
+  if (Number.isNaN(ms)) return generatedAt;
+  return new Date(ms + 30 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function shortReceiptId(planDigest, generatedAt) {
+  return hashJson({ planDigest, generatedAt }).slice("sha256:".length, "sha256:".length + 12);
+}
+function applyExitCode2(result) {
+  switch (result.outcome) {
+    case "applied":
+    case "already_applied":
+      return EXIT.OK;
+    case "stale":
+    case "conflict":
+      return EXIT.ERROR;
+    case "rolled_back":
+    case "rollback_failed":
+      return EXIT.ERROR;
+  }
+}
+function renderPlans(hostPlans, written) {
+  const lines = ["CallLint integrate \u2014 preflight install plan (read-only; nothing written)\n"];
+  for (const hp of hostPlans) {
+    if (hp.plan) {
+      lines.push(`  ${hp.host}: ${hp.plan.operations.length} op(s) \u2192 ${hp.configPath}`);
+      lines.push(`    plan digest: ${hp.plan.planDigest}`);
+      const planRef = written.get(hp.host) ?? "<saved-plan.json>";
+      lines.push(`    apply with:  calllint integrate --apply --plan ${planRef} --approve ${hp.plan.planDigest}`);
+    } else {
+      lines.push(`  ${hp.host}: no change \u2014 ${hp.note}`);
+    }
+  }
+  lines.push("\nInstalling the CallLint preflight server does not block your agent (ADR 0051); it recommends. CallLint never executes the servers it judges.");
+  return lines.join("\n") + "\n";
+}
+function renderApply(result) {
+  const head = `integrate apply: ${result.outcome} (${result.state}) \u2014 host ${result.host}`;
+  const trail = result.notes.map((n) => `  ${n}`).join("\n");
+  const rb = result.rolledBack ? "\n  rolled back to the original config (verify failed)." : "";
+  return `${head}
+${trail}${rb}
+`;
+}
+function integrateHelp() {
+  return {
+    stdout: [
+      "calllint integrate \u2014 install the CallLint preflight server into your agent hosts",
+      "",
+      "  calllint integrate                 detect hosts + print an install plan (read-only)",
+      "  calllint integrate --host cursor   plan for one host only",
+      "  calllint integrate --write-plan    persist each plan to .calllint/plans/<id>.json",
+      "  calllint integrate --json          machine-readable plan",
+      "  calllint integrate --apply --plan <p.json> --approve <digest>",
+      "                                     apply an approved plan (atomic, verified, auto-rollback)",
+      "",
+      "Idempotent: a host that already has the calllint server yields no change.",
+      "Plan-only by default; --apply is the only writer and reuses the audited",
+      "trust-apply engine. Installing the preflight does not block your agent (ADR 0051)."
+    ].join("\n") + "\n",
+    stderr: "",
+    exitCode: EXIT.OK
+  };
+}
+function usage(msg) {
+  return { stdout: "", stderr: msg, exitCode: EXIT.USAGE };
+}
+
+// ../../packages/telemetry-contract/src/events.ts
+var ALLOWED_EVENTS = [
+  "install_completed",
+  "preflight_completed",
+  "decision_safe",
+  "decision_review",
+  "decision_block",
+  "decision_unknown",
+  "approval_created",
+  "apply_completed",
+  "verify_completed",
+  "rollback_completed",
+  "guard_drift_detected",
+  "trust_page_viewed",
+  "trust_page_to_install",
+  "partner_api_called",
+  "badge_rendered"
+];
+var FORBIDDEN_FIELDS = [
+  "rawConfig",
+  "command",
+  "environmentValue",
+  "secret",
+  "fileContents",
+  "privateRepository",
+  "userPrompt",
+  "findingEvidenceText"
+];
+var SOURCES = ["cli", "ci", "server", "install"];
+var RESULTS2 = ["SAFE", "REVIEW", "BLOCK", "UNKNOWN"];
+var EVENT_VERSION = "1.0.0";
+
+// ../../packages/telemetry-contract/src/tiers.ts
+var TIER_POLICY = {
+  server: {
+    source: "server",
+    defaultEnabled: true,
+    requiresNotice: false,
+    rationale: "Own web/API property; no user machine involved (funnel top)."
+  },
+  install: {
+    source: "install",
+    defaultEnabled: true,
+    requiresNotice: false,
+    rationale: "Attributed at the click/redirect surface, not on the machine."
+  },
+  ci: {
+    source: "ci",
+    defaultEnabled: true,
+    requiresNotice: true,
+    rationale: "The installing org is the controller; standard for CI tooling; disableable."
+  },
+  cli: {
+    source: "cli",
+    defaultEnabled: false,
+    requiresNotice: true,
+    rationale: "Personal machine \u2192 consent-first (opt-in, default off, first-run consent)."
+  }
+};
+function isEnabledByDefault(source) {
+  return TIER_POLICY[source].defaultEnabled;
+}
+
+// ../../packages/telemetry-contract/src/sanitize.ts
+function bucketDuration(ms) {
+  if (ms == null || !Number.isFinite(ms) || ms < 0) return void 0;
+  if (ms < 100) return "<100ms";
+  if (ms < 500) return "100-500ms";
+  if (ms < 2e3) return "500-2000ms";
+  return ">2000ms";
+}
+var isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+function sanitizeEvent(input) {
+  for (const f of FORBIDDEN_FIELDS) {
+    if (f in input) {
+      throw new Error(`telemetry: forbidden field "${f}" present on event \u2014 refusing to sanitize`);
+    }
+  }
+  if (!ALLOWED_EVENTS.includes(input.eventName)) {
+    throw new Error(`telemetry: unknown eventName "${input.eventName}"`);
+  }
+  if (!SOURCES.includes(input.source)) {
+    throw new Error(`telemetry: unknown source "${input.source}"`);
+  }
+  if (input.result != null && !RESULTS2.includes(input.result)) {
+    throw new Error(`telemetry: unknown result "${input.result}"`);
+  }
+  const out = {
+    eventVersion: EVENT_VERSION,
+    eventName: input.eventName,
+    timestamp: isNonEmptyString(input.timestamp) ? input.timestamp : "",
+    source: input.source
+  };
+  if (isNonEmptyString(input.hostFamily)) out.hostFamily = input.hostFamily;
+  if (input.result != null) out.result = input.result;
+  const bucket = bucketDuration(input.durationMs);
+  if (bucket) out.durationBucket = bucket;
+  if (isNonEmptyString(input.inputKind)) out.inputKind = input.inputKind;
+  if (isNonEmptyString(input.anonymousInstallationId)) {
+    out.anonymousInstallationId = input.anonymousInstallationId;
+  }
+  if (isNonEmptyString(input.productVersion)) out.productVersion = input.productVersion;
+  return out;
+}
+
+// ../../packages/telemetry-emit/src/gate.ts
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+function isTelemetryDisabledByEnv(env) {
+  const v = env["CALLLINT_TELEMETRY"];
+  return v != null && DISABLED_VALUES.has(v.trim().toLowerCase());
+}
+function shouldEmit(source, state = {}) {
+  const env = state.env ?? {};
+  if (isTelemetryDisabledByEnv(env)) return false;
+  if (source === "cli") return state.consented === true;
+  return isEnabledByDefault(source);
+}
+
+// ../../packages/telemetry-emit/src/sink.ts
+var noopSink = {
+  kind: "noop",
+  write() {
+  }
+};
+
+// ../../packages/telemetry-emit/src/emitter.ts
+function createEmitter(config) {
+  const sink = config.sink ?? noopSink;
+  const gate = { consented: config.consented, env: config.env };
+  return {
+    source: config.source,
+    emit(input) {
+      if (!shouldEmit(config.source, gate)) {
+        return { status: "gated", reason: "disabled-or-no-consent" };
+      }
+      let event;
+      try {
+        event = sanitizeEvent({ ...input, source: config.source });
+      } catch (err2) {
+        return { status: "dropped", reason: err2 instanceof Error ? err2.message : String(err2) };
+      }
+      sink.write(event);
+      return { status: "emitted", event };
+    }
+  };
+}
+
+// src/telemetry.ts
+var VERDICT_EVENT = {
+  SAFE: "decision_safe",
+  REVIEW: "decision_review",
+  BLOCK: "decision_block",
+  UNKNOWN: "decision_unknown"
+};
+function eventFor(signal) {
+  if (signal.event) return signal.event;
+  if (signal.verdict) return VERDICT_EVENT[signal.verdict];
+  return null;
+}
+function buildCliEmitter(env, opts = {}) {
+  return createEmitter({ source: "cli", env, sink: opts.sink, consented: opts.consented });
+}
+function emitCommandSignal(emitter, signal, productVersion) {
+  if (!emitter || !signal) return;
+  try {
+    const eventName = eventFor(signal);
+    if (!eventName) return;
+    const input = {
+      eventName,
+      ...signal.verdict ? { result: signal.verdict } : {},
+      ...signal.hostFamily ? { hostFamily: signal.hostFamily } : {},
+      ...signal.inputKind ? { inputKind: signal.inputKind } : {},
+      ...productVersion ? { productVersion } : {}
+    };
+    emitter.emit(input);
+  } catch {
+  }
+}
+
 // src/run.ts
 function run(argv, deps) {
+  const result = dispatch(argv, deps);
+  emitCommandSignal(deps.emitter, result.telemetry, deps.toolVersion);
+  return result;
+}
+function dispatch(argv, deps) {
   const args = parseArgs(argv);
   const cmd = args.command;
   if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
@@ -10171,6 +10809,8 @@ function run(argv, deps) {
       return evidenceCommand(args, { cwd: deps.cwd });
     case "trust":
       return trustCommand(args, { cwd: deps.cwd, generatedAt: deps.generatedAt, toolVersion: deps.toolVersion });
+    case "integrate":
+      return integrateCommand(args, { cwd: deps.cwd, generatedAt: deps.generatedAt, toolVersion: deps.toolVersion });
     case "guard":
       return guardCommand(args, {
         cwd: deps.cwd,
@@ -10451,13 +11091,13 @@ async function breathe(argv, deps = {}) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { dirname as dirname7, join as join19 } from "node:path";
 function resolveToolVersion() {
   try {
-    const pkgPath = join18(dirname7(fileURLToPath(import.meta.url)), "..", "package.json");
-    const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
+    const pkgPath = join19(dirname7(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
     return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -10467,7 +11107,7 @@ function resolveToolVersion() {
 // src/index.ts
 function readStdin() {
   try {
-    return readFileSync21(0, "utf8");
+    return readFileSync22(0, "utf8");
   } catch {
     return "";
   }
@@ -10510,6 +11150,7 @@ async function main() {
     await breathe(argv);
   } catch {
   }
+  const emitter = buildCliEmitter(process.env);
   const result = run(argv, {
     cwd: process.cwd(),
     readStdin,
@@ -10517,7 +11158,8 @@ async function main() {
     generatedAt,
     online,
     toolVersion: resolveToolVersion(),
-    getChangedFilesDiff: () => gitChangedFiles(process.cwd())
+    getChangedFilesDiff: () => gitChangedFiles(process.cwd()),
+    emitter
   });
   if (result.stdout) process.stdout.write(result.stdout + "\n");
   if (result.stderr) process.stderr.write(result.stderr + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calllint",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Evidence-backed security verdicts for MCP servers and agent tools. Lint agent tool-call risk before tools run — SAFE / REVIEW / BLOCK / UNKNOWN, with evidence. Never executes the server it judges.",
   "keywords": [
     "mcp",
@@ -50,6 +50,7 @@
   "dependencies": {},
   "devDependencies": {
     "@calllint/action-analyzer": "workspace:*",
+    "@calllint/agent-triggers": "workspace:*",
     "@calllint/core": "workspace:*",
     "@calllint/discovery": "workspace:*",
     "@calllint/evidence": "workspace:*",
@@ -62,6 +63,8 @@
     "@calllint/report-renderer": "workspace:*",
     "@calllint/resolver": "workspace:*",
     "@calllint/signature": "workspace:*",
+    "@calllint/telemetry-contract": "workspace:*",
+    "@calllint/telemetry-emit": "workspace:*",
     "@calllint/types": "workspace:*",
     "esbuild": "^0.21.5"
   }