codiedev 0.9.50 → 0.9.52

package/dist/utils.js

@@ -64,7 +64,6 @@ exports.openCodeInstalled = openCodeInstalled;
 exports.installOpenCodeCapturePlugin = installOpenCodeCapturePlugin;
 exports.vscodeCopilotInstalled = vscodeCopilotInstalled;
 exports.upsertCodiedevHook = upsertCodiedevHook;
-exports.removeCodiedevHook = removeCodiedevHook;
 exports.installHook = installHook;
 exports.ensureDiscoveryHookInstalled = ensureDiscoveryHookInstalled;
 exports.ensureBackupHookInstalled = ensureBackupHookInstalled;
@@ -83,6 +82,7 @@ exports.cleanupVSCodeMcp = cleanupVSCodeMcp;
 exports.cleanupCodexMcp = cleanupCodexMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
+exports.ensureCodexLimitHookInstalled = ensureCodexLimitHookInstalled;
 exports.installCursorHook = installCursorHook;
 exports.parseClaudeSteering = parseClaudeSteering;
 exports.parseCodexSteering = parseCodexSteering;
@@ -1052,15 +1052,10 @@ function openCodeInstalled() {
 /** Install a dormant global OpenCode adapter. Installing it unconditionally
  * keeps `codiedev connect` as the only setup step even when Codie/OpenCode is
  * installed later. OpenCode loads this file from its documented plugin dir. */
-function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
+function installOpenCodeCapturePlugin() {
     const start = resolveHookInvocation("session-start-opencode");
     const capture = resolveHookInvocation("capture-opencode");
     const finish = resolveHookInvocation("capture-opencode-final");
-    const backup = resolveHookInvocation("backup");
-    const prompt = resolveHookInvocation("discover-codie");
-    const securityPre = resolveHookInvocation("security-pre-codie");
-    const securityPost = resolveHookInvocation("security-post-codie");
-    const securityFailure = resolveHookInvocation("security-failure-codie");
     const source = `// Managed by codiedev connect. Safe to remove and reinstall.\n` +
         `import { spawn, spawnSync } from "node:child_process";\n` +
         `import { mkdir, writeFile } from "node:fs/promises";\n` +
@@ -1069,15 +1064,8 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `const START = ${JSON.stringify(start)};\n` +
         `const CAPTURE = ${JSON.stringify(capture)};\n` +
         `const FINISH = ${JSON.stringify(finish)};\n` +
-        `const BACKUP = ${JSON.stringify(backup)};\n` +
-        `const PROMPT = ${JSON.stringify(prompt)};\n` +
-        `const SECURITY_PRE = ${JSON.stringify(securityPre)};\n` +
-        `const SECURITY_POST = ${JSON.stringify(securityPost)};\n` +
-        `const SECURITY_FAILURE = ${JSON.stringify(securityFailure)};\n` +
-        `const AGENT_SECURITY_ENABLED = ${JSON.stringify(agentSecurityEnabled)};\n` +
         `const fingerprints = new Map();\n\n` +
         `const transcriptPaths = new Map();\n\n` +
-        `const sessionDirectories = new Map();\n\n` +
         `function sessionId(event) {\n` +
         `  return event?.properties?.sessionID ?? event?.properties?.sessionId ?? event?.properties?.info?.id ?? null;\n` +
         `}\n\n` +
@@ -1091,75 +1079,19 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `function dispatchSync(invocation, payload) {\n` +
         `  try { spawnSync(invocation.command, invocation.args, { input: JSON.stringify(payload), stdio: ["pipe", "ignore", "ignore"], timeout: 1500 }); } catch {}\n` +
         `}\n\n` +
-        `function enforceSync(invocation, payload) {\n` +
-        `  const result = spawnSync(invocation.command, invocation.args, { input: JSON.stringify(payload), encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], timeout: 1500 });\n` +
-        `  if (result.error) return null;\n` +
-        `  try {\n` +
-        `    const decision = JSON.parse(result.stdout || "{}");\n` +
-        `    const denied = decision?.decision === "block" || decision?.hookSpecificOutput?.permissionDecision === "deny";\n` +
-        `    return denied ? (decision?.reason || decision?.hookSpecificOutput?.permissionDecisionReason || "Codie security policy blocked this action") : null;\n` +
-        `  } catch (error) {\n` +
-        `    if (error instanceof SyntaxError) return null;\n` +
-        `    return null;\n` +
-        `  }\n` +
-        `}\n\n` +
         `export const CodiedevCapture = async ({ client, directory, worktree }) => {\n` +
-        `  const enforce = async (invocation, payload) => {\n` +
-        `    const reason = enforceSync(invocation, payload);\n` +
-        `    if (!reason) return;\n` +
-        `    try { await client.tui.showToast({ title: "Codie Security", message: reason, variant: "error", duration: 10000 }); } catch {}\n` +
-        `    if (process.env.CODIEDEV_SECURITY_BLOCK_OUTPUT === "marker") {\n` +
-        `      process.stderr.write("__CODIEDEV_SECURITY_BLOCK__" + JSON.stringify({ reason }) + "\\n");\n` +
-        `      process.exit(1);\n` +
-        `    } else {\n` +
-        `      process.stderr.write("\\nCodie Security blocked this action:\\n" + reason + "\\n");\n` +
-        `    }\n` +
-        `    throw new Error(reason);\n` +
-        `  };\n` +
-        `  const resolveCwd = async (id, hint) => {\n` +
-        `    if (typeof hint === "string" && hint && hint !== "/") { sessionDirectories.set(id, hint); return hint; }\n` +
-        `    const remembered = sessionDirectories.get(id);\n` +
-        `    if (remembered) return remembered;\n` +
-        `    try {\n` +
-        `      const response = await client.session.get({ path: { id } });\n` +
-        `      const session = response?.data ?? response;\n` +
-        `      if (typeof session?.directory === "string" && session.directory) { sessionDirectories.set(id, session.directory); return session.directory; }\n` +
-        `    } catch {}\n` +
-        `    const fallback = worktree || directory || process.cwd();\n` +
-        `    sessionDirectories.set(id, fallback);\n` +
-        `    return fallback;\n` +
-        `  };\n` +
         `  const finalizeAll = () => {\n` +
         `    for (const [id, transcriptPath] of transcriptPaths) {\n` +
-        `      const cwd = sessionDirectories.get(id) || worktree || directory || process.cwd();\n` +
+        `      const cwd = worktree || directory || process.cwd();\n` +
         `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
         `    }\n` +
         `  };\n` +
         `  process.once("exit", finalizeAll);\n` +
         `  return ({\n` +
-        `  "chat.message": async (input, output) => {\n` +
-        `    const id = input?.sessionID ?? input?.sessionId ?? "unknown";\n` +
-        `    const cwd = await resolveCwd(id);\n` +
-        `    const prompt = Array.isArray(output?.parts) ? output.parts.filter((part) => part?.type === "text").map((part) => part.text || "").join("\\n") : "";\n` +
-        `    await enforce(PROMPT, { sessionId: id, cwd, prompt });\n` +
-        `  },\n` +
-        `  "tool.execute.before": async (input, output) => {\n` +
-        `    if (!AGENT_SECURITY_ENABLED) return;\n` +
-        `    const id = input?.sessionID ?? input?.sessionId ?? "unknown";\n` +
-        `    const cwd = await resolveCwd(id);\n` +
-        `    await enforce(SECURITY_PRE, { sessionId: id, cwd, toolName: input?.tool ?? "unknown", toolUseId: input?.callID, toolInput: output?.args ?? output });\n` +
-        `  },\n` +
-        `  "tool.execute.after": async (input, output) => {\n` +
-        `    if (!AGENT_SECURITY_ENABLED) return;\n` +
-        `    const id = input?.sessionID ?? input?.sessionId ?? "unknown";\n` +
-        `    const cwd = await resolveCwd(id);\n` +
-        `    const payload = { sessionId: id, cwd, toolName: input?.tool ?? "unknown", toolUseId: input?.callID, toolInput: input?.args, toolResponse: output };\n` +
-        `    dispatch(output?.error ? SECURITY_FAILURE : SECURITY_POST, payload);\n` +
-        `  },\n` +
         `  event: async ({ event }) => {\n` +
         `    const id = sessionId(event);\n` +
         `    if (!id) return;\n` +
-        `    const cwd = await resolveCwd(id, event?.properties?.info?.directory);\n` +
+        `    const cwd = worktree || directory || process.cwd();\n` +
         `    if (event.type === "session.created") {\n` +
         `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
         `      return;\n` +
@@ -1168,7 +1100,6 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `      const transcriptPath = transcriptPaths.get(id);\n` +
         `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
         `      transcriptPaths.delete(id);\n` +
-        `      sessionDirectories.delete(id);\n` +
         `      fingerprints.delete(id);\n` +
         `      return;\n` +
         `    }\n` +
@@ -1188,7 +1119,6 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `      await writeFile(transcriptPath, JSON.stringify(list), { mode: 0o600 });\n` +
         `      transcriptPaths.set(id, transcriptPath);\n` +
         `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
-        `      dispatch(BACKUP, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
         `    } catch {}\n` +
         `  },\n` +
         `  });\n` +
@@ -1251,36 +1181,7 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     });
     hooks[eventName] = filtered;
 }
-/** Remove Codiedev's entries for one event while preserving foreign hooks. */
-function removeCodiedevHook(hooks, eventName) {
-    const entries = hooks[eventName];
-    if (!Array.isArray(entries))
-        return false;
-    let changed = false;
-    const filtered = entries.flatMap((entry) => {
-        const record = entry;
-        const inner = record.hooks;
-        if (!Array.isArray(inner))
-            return [record];
-        const remaining = inner.filter((hook) => {
-            const remove = (0, detection_1.isCodiedevHookCommand)(hook.command);
-            if (remove)
-                changed = true;
-            return !remove;
-        });
-        if (remaining.length === 0)
-            return [];
-        return [{ ...record, hooks: remaining }];
-    });
-    if (!changed)
-        return false;
-    if (filtered.length === 0)
-        delete hooks[eventName];
-    else
-        hooks[eventName] = filtered;
-    return true;
-}
-function installHook(agentSecurityEnabled = true) {
+function installHook() {
     let settings = {};
     try {
         if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
@@ -1297,18 +1198,6 @@ function installHook(agentSecurityEnabled = true) {
     const hooks = settings.hooks;
     // SessionEnd → capture (upload the finished session for the team library).
     upsertCodiedevHook(hooks, "SessionEnd", "capture");
-    // Tool boundaries → ADR shadow detection. PreToolUse is the eventual
-    // enforcement point; alert mode always returns allow.
-    if (agentSecurityEnabled) {
-        upsertCodiedevHook(hooks, "PreToolUse", "security-pre");
-        upsertCodiedevHook(hooks, "PostToolUse", "security-post");
-        upsertCodiedevHook(hooks, "PostToolUseFailure", "security-failure");
-    }
-    else {
-        removeCodiedevHook(hooks, "PreToolUse");
-        removeCodiedevHook(hooks, "PostToolUse");
-        removeCodiedevHook(hooks, "PostToolUseFailure");
-    }
     // UserPromptSubmit → discover (surface a matching team skill for the task).
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover");
     // Stop → backup (auto-back-up changed artifact files to your private library).
@@ -1410,7 +1299,7 @@ function ensureLimitHookInstalled() {
 //      shrinks that window and removes the intra-process version entirely.
 // The per-hook ensure* functions below are kept for tests/back-compat but are
 // no longer called from the hook entrypoint.
-function ensureAllCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.agentSecurityEnabled === true) {
+function ensureAllCodiedevHooksInstalled() {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
             return; // not a Claude Code user
@@ -1423,17 +1312,8 @@ function ensureAllCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.ag
             ["StopFailure", "limit", "rate_limit"],
             ["SessionStart", "session-start"],
         ];
-        if (agentSecurityEnabled) {
-            wanted.splice(1, 0, ["PreToolUse", "security-pre"], ["PostToolUse", "security-post"], ["PostToolUseFailure", "security-failure"]);
-        }
-        let changed = false;
-        if (!agentSecurityEnabled) {
-            for (const eventName of ["PreToolUse", "PostToolUse", "PostToolUseFailure"]) {
-                changed = removeCodiedevHook(hooks, eventName) || changed;
-            }
-        }
         const missing = wanted.filter(([eventName]) => !hasCodiedevHook(hooks, eventName));
-        if (missing.length === 0 && !changed)
+        if (missing.length === 0)
             return; // steady state: no write, no churn
         settings.hooks = hooks;
         for (const [eventName, subcommand, matcher] of missing) {
@@ -1874,7 +1754,7 @@ function installCodexMcp() {
 // Codex doesn't have a SessionEnd event yet — Stop fires after every turn.
 // The backend dedupes on (companyId, sessionId) and replaces the stored
 // transcript on re-upload, so the latest turn's snapshot wins.
-function installCodexHook(agentSecurityEnabled = true) {
+function installCodexHook() {
     let hooksFile = {};
     try {
         if (fs.existsSync(CODEX_HOOKS_PATH)) {
@@ -1889,8 +1769,9 @@ function installCodexHook(agentSecurityEnabled = true) {
         hooksFile.hooks = {};
     }
     const hooks = hooksFile.hooks;
-    if (!hooks.Stop)
+    if (!hooks.Stop) {
         hooks.Stop = [];
+    }
     const existing = hooks.Stop;
     const filtered = existing.filter((hook) => {
         const inner = hook.hooks;
@@ -1898,6 +1779,15 @@ function installCodexHook(agentSecurityEnabled = true) {
             return true;
         return !inner.some((h) => (0, detection_1.isCodiedevHookCommand)(h.command));
     });
+    filtered.push({
+        hooks: [
+            {
+                type: "command",
+                command: resolveHookCommand("limit-codex"),
+                timeout: 10,
+            },
+        ],
+    });
     filtered.push({
         hooks: [
             {
@@ -1918,28 +1808,41 @@ function installCodexHook(agentSecurityEnabled = true) {
         ],
     });
     hooks.Stop = filtered;
-    // Codex uses the same Claude-style matcher-group shape. Keep these as
-    // separate entries because Codex hook coverage is still evolving and a
-    // malformed/unavailable post hook must not interfere with PreToolUse.
-    if (agentSecurityEnabled) {
-        upsertCodiedevHook(hooks, "PreToolUse", "security-pre-codex");
-        upsertCodiedevHook(hooks, "PostToolUse", "security-post-codex");
-        upsertCodiedevHook(hooks, "PostToolUseFailure", "security-failure-codex");
-    }
-    else {
-        removeCodiedevHook(hooks, "PreToolUse");
-        removeCodiedevHook(hooks, "PostToolUse");
-        removeCodiedevHook(hooks, "PostToolUseFailure");
-    }
-    // Prompt guard + skill discovery. The guard runs locally before any prompt
-    // content can reach either the model or Codiedev's discovery endpoint.
-    upsertCodiedevHook(hooks, "UserPromptSubmit", "discover-codex");
     if (!fs.existsSync(CODEX_DIR)) {
         fs.mkdirSync(CODEX_DIR, { recursive: true });
     }
     fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
     (0, codexHookTrust_1.writeCodexHookTrust)(CODEX_CONFIG_PATH, CODEX_HOOKS_PATH, hooksFile);
 }
+// Existing Codex users already have capture-codex on Stop. After a CLI
+// upgrade, that hook repairs the new limit reporter without requiring connect.
+function ensureCodexLimitHookInstalled() {
+    try {
+        if (!fs.existsSync(CODEX_HOOKS_PATH))
+            return;
+        const hooksFile = JSON.parse(fs.readFileSync(CODEX_HOOKS_PATH, "utf8"));
+        const hooks = (hooksFile.hooks ?? {});
+        const stop = Array.isArray(hooks.Stop) ? hooks.Stop : [];
+        const present = stop.some((group) => {
+            const inner = group.hooks;
+            return Array.isArray(inner) && inner.some((hook) => typeof hook.command === "string" && /(?:^|\s)limit-codex(?:\s|$)/.test(hook.command));
+        });
+        if (present)
+            return;
+        stop.unshift({
+            hooks: [{ type: "command", command: resolveHookCommand("limit-codex"), timeout: 10 }],
+        });
+        hooks.Stop = stop;
+        hooksFile.hooks = hooks;
+        fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
+        // Trust keys include each hook's positional index. Adding the new hook at
+        // the front shifts capture/backup, so refresh every Codiedev hash together.
+        (0, codexHookTrust_1.writeCodexHookTrust)(CODEX_CONFIG_PATH, CODEX_HOOKS_PATH, hooksFile);
+    }
+    catch {
+        // Best-effort: capture must never fail because hook repair did.
+    }
+}
 // Cursor's hooks.json uses { version: 1, hooks: { sessionEnd: [{ command, type, timeout }] } }.
 // `sessionEnd` fires when a conversation closes (completed, aborted, error,
 // window_close, user_close); the base stdin payload includes transcript_path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.50",
+  "version": "0.9.52",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",
@@ -12,8 +12,7 @@
     "dev": "tsc --watch",
     "prepublishOnly": "tsc",
     "test": "vitest run",
-    "test:security-beta": "vitest run src/__tests__/security.test.ts src/__tests__/securityCommandEntitlement.test.ts src/__tests__/securityDeepScan.test.ts src/__tests__/securityDoctor.test.ts src/__tests__/securityEntitlementInstall.test.ts src/__tests__/securityFeature.test.ts src/__tests__/securityInstall.test.ts src/__tests__/securityInventory.test.ts src/__tests__/securityPilot.test.ts src/__tests__/securityPolicy.test.ts src/__tests__/securitySession.test.ts src/__tests__/codexHookTrust.test.ts src/__tests__/codieSecurityAdapterWiring.test.ts && tsc && node dist/cli.js security pilot --json",
-    "test:security-pilot": "vitest run src/__tests__/security.test.ts src/__tests__/securityInstall.test.ts src/__tests__/securityPilot.test.ts src/__tests__/codieSecurityAdapterWiring.test.ts && tsc && node dist/cli.js security pilot --json",
+    "test:functional": "vitest run src/__tests__/limitEvent.functional.test.ts",
     "test:watch": "vitest"
   },
   "files": [
@@ -37,18 +36,12 @@
     "session-capture"
   ],
   "homepage": "https://codiedev.com",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Signal-and-Code/codiedev.git",
-    "directory": "packages/codiedev-cli"
-  },
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/commands/security.d.ts

@@ -1 +0,0 @@
-export declare function runSecurityCommand(args: string[]): Promise<void>;

package/dist/commands/security.js

@@ -1,156 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSecurityCommand = runSecurityCommand;
-const securityInstall_1 = require("../securityInstall");
-const securityPilot_1 = require("../securityPilot");
-const securityPolicy_1 = require("../securityPolicy");
-const securityInventory_1 = require("../securityInventory");
-const securityDeepScan_1 = require("../securityDeepScan");
-const utils_1 = require("../utils");
-const securityDoctor_1 = require("../securityDoctor");
-const securityFeature_1 = require("../securityFeature");
-const SECURITY_USAGE = "Usage: codiedev security <doctor|pilot|inventory|scan|sync|rollback> [--json] [--deep] [--connect-mcp] [--supply-chain] [--no-upload] [--yes]";
-function printPilot(json) {
-    const report = (0, securityPilot_1.runSyntheticSecurityPilot)();
-    if (json) {
-        console.log(JSON.stringify(report, null, 2));
-        return report.ok;
-    }
-    console.log("\nCodiedev security pilot — synthetic, side-effect-free validation\n");
-    for (const item of report.cases) {
-        console.log(`${item.passed ? "✓" : "✗"} ${item.surface}: ${item.name} (${item.actual})`);
-    }
-    console.log(`\n${report.ok ? "PASS" : "FAIL"}: ${report.cases.filter((item) => item.passed).length}/${report.cases.length} policy checks matched.`);
-    console.log("No commands were executed and no real credentials were used.\n");
-    return report.ok;
-}
-function printDoctor(json, companyId) {
-    const result = (0, securityDoctor_1.collectSecurityDoctorReport)(companyId);
-    if (json) {
-        console.log(JSON.stringify(result, null, 2));
-        return result.ok;
-    }
-    console.log("\nCodiedev doctor — Agent Security details\n");
-    for (const check of (0, securityDoctor_1.securityDoctorChecks)(result)) {
-        const mark = check.status === "pass" ? "✓" : check.status === "warn" ? "!" : "✗";
-        console.log(`${mark} ${check.name}: ${check.detail}`);
-    }
-    console.log(`\n${result.ok ? "PASS" : "FAIL"}: ${result.ok ? "endpoint security is healthy" : "run `codiedev connect`, then repeat this check"}.\n`);
-    return result.ok;
-}
-async function runSecurityCommand(args) {
-    const subcommand = args.find((arg) => !arg.startsWith("-")) ?? "doctor";
-    const json = args.includes("--json");
-    if (args.includes("--help") || args.includes("-h") || subcommand === "help") {
-        console.log(SECURITY_USAGE);
-        return;
-    }
-    const connectedConfig = (0, utils_1.readConfig)();
-    const requiresEntitlement = !["pilot", "self-test"].includes(subcommand);
-    if (requiresEntitlement && (!connectedConfig || !(0, securityFeature_1.isAgentSecurityEnabled)(connectedConfig))) {
-        const detail = connectedConfig
-            ? `Agent Security is not enabled for ${connectedConfig.companyName}.`
-            : "Not connected. Run `codiedev connect` first.";
-        if (json)
-            console.log(JSON.stringify({ schemaVersion: 1, enabled: false, detail }, null, 2));
-        else
-            console.log(`\n${detail}\n`);
-        return;
-    }
-    if (subcommand === "inventory" || subcommand === "scan") {
-        const workspaceFlag = args.indexOf("--workspace");
-        const workspace = workspaceFlag >= 0 && args[workspaceFlag + 1]
-            ? args[workspaceFlag + 1]
-            : process.cwd();
-        const inventory = (0, securityInventory_1.buildSecurityInventory)({ workspace });
-        const deep = subcommand === "scan" && args.includes("--deep")
-            ? (0, securityDeepScan_1.runDeepSecurityScan)(inventory, {
-                workspace,
-                connectMcp: args.includes("--connect-mcp"),
-                supplyChain: args.includes("--supply-chain"),
-            })
-            : undefined;
-        const uploadableInventory = deep ? (0, securityDeepScan_1.mergeDeepScanFindings)(inventory, deep) : inventory;
-        let upload;
-        const config = (0, utils_1.readConfig)();
-        if (config && !args.includes("--no-upload")) {
-            try {
-                upload = await (0, securityInventory_1.uploadSecurityInventory)(uploadableInventory, config);
-            }
-            catch (error) {
-                if (!json)
-                    console.warn(`Inventory upload failed; local scan is still valid: ${error.message}`);
-            }
-        }
-        const output = { inventory: uploadableInventory, scanners: (0, securityInventory_1.scannerAvailability)(), ...(deep ? { deep } : {}), ...(upload ? { upload } : {}) };
-        if (json)
-            console.log(JSON.stringify(output, null, 2));
-        else {
-            const risky = inventory.components.filter((component) => component.findings.length > 0).length;
-            console.log(`\nCodiedev security inventory — ${inventory.components.length} components, ${risky} with local findings, ${inventory.drift.length} changed\n`);
-            const counts = new Map();
-            for (const component of inventory.components)
-                counts.set(component.kind, (counts.get(component.kind) ?? 0) + 1);
-            for (const [kind, count] of [...counts].sort())
-                console.log(`  ${kind}: ${count}`);
-            if (deep)
-                for (const run of deep.runs)
-                    console.log(`  ${run.scanner}: ${run.status} — ${run.detail}`);
-            if (upload)
-                console.log(`\nUploaded ${upload.accepted} component records to the security workspace.`);
-            console.log("\nUse --json for machine-readable hashes and findings. Use scan --deep for installed OSS scanners; --connect-mcp and --supply-chain are explicit because they start or download third-party code.\n");
-        }
-        return;
-    }
-    if (subcommand === "sync") {
-        const config = (0, utils_1.readConfig)();
-        if (!config) {
-            console.error("Not connected. Run `codiedev connect` first.");
-            process.exitCode = 1;
-            return;
-        }
-        try {
-            const policy = await (0, securityPolicy_1.syncEndpointSecurityPolicy)(config);
-            if (json)
-                console.log(JSON.stringify({ ok: true, policy }, null, 2));
-            else {
-                const verification = (0, securityPolicy_1.verifyEndpointSecurityPolicySignature)(policy);
-                console.log(`Security policy v${policy.policyVersion} synced (${policy.enforcementMode} mode; ${verification.detail}).`);
-            }
-        }
-        catch (error) {
-            console.error(`Security policy sync failed: ${error.message}`);
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (subcommand === "rollback") {
-        if (!args.includes("--yes")) {
-            console.error("Rollback overwrites the installed agent hook configurations. Re-run with `codiedev security rollback --yes` after confirming the snapshot shown by `codiedev doctor`.");
-            process.exitCode = 1;
-            return;
-        }
-        try {
-            const result = (0, securityInstall_1.restoreSecurityInstallSnapshot)((0, securityInstall_1.readSecurityInstallManifest)());
-            if (json)
-                console.log(JSON.stringify({ schemaVersion: 1, ok: true, ...result }, null, 2));
-            else
-                console.log(`Restored ${result.restored} hook configuration(s) from snapshot ${result.snapshotId}.`);
-        }
-        catch (error) {
-            console.error(`Rollback failed: ${error.message}`);
-            process.exitCode = 1;
-        }
-        return;
-    }
-    const ok = subcommand === "pilot" || subcommand === "self-test"
-        ? printPilot(json)
-        : subcommand === "doctor" || subcommand === "status"
-            ? printDoctor(json, connectedConfig.companyId)
-            : false;
-    if (!["pilot", "self-test", "doctor", "status"].includes(subcommand)) {
-        console.error(SECURITY_USAGE);
-    }
-    if (!ok)
-        process.exitCode = 1;
-}

package/dist/security.d.ts

@@ -1,97 +0,0 @@
-export type SecurityHookPhase = "pre" | "post" | "failure";
-export type AgentSurface = "claude-code" | "codex" | "codie-harness";
-export interface RawSecurityHookInput {
-    session_id?: string;
-    sessionId?: string;
-    cwd?: string;
-    hook_event_name?: string;
-    hookEventName?: string;
-    tool_name?: string;
-    toolName?: string;
-    tool_input?: unknown;
-    toolInput?: unknown;
-    tool_response?: unknown;
-    toolResponse?: unknown;
-    tool_use_id?: string;
-    toolUseId?: string;
-    duration_ms?: number;
-    durationMs?: number;
-    error?: unknown;
-    prompt?: string;
-}
-export interface SecurityWorkflowEvent {
-    schemaVersion: 1;
-    source: AgentSurface;
-    phase: SecurityHookPhase;
-    sessionId: string;
-    toolName: string;
-    toolUseId?: string;
-    cwd?: string;
-    observedAt: number;
-    toolDurationMs?: number;
-    payload: unknown;
-    redactionCount: number;
-    localDecision?: LocalSecurityAction;
-    localCategory?: LocalSecurityDecision["category"];
-    endpointId?: string;
-    endpointName?: string;
-    cliVersion?: string;
-}
-export type LocalSecurityAction = "allow" | "alert" | "block";
-export type SecurityCategory = "secret_in_prompt" | "secret_exfiltration" | "destructive_outside_workspace" | "sensitive_file_read" | "sensitive_file_write" | "protected_agent_config_write" | "unapproved_network_egress" | "untrusted_mcp_tool" | "unapproved_command" | "obfuscated_shell_command" | "package_install" | "sensitive_read_then_egress";
-export interface EndpointSecurityPolicy {
-    schemaVersion: 1;
-    policyVersion: number;
-    enforcementMode: "alert" | "block";
-    rules: Partial<Record<SecurityCategory, LocalSecurityAction>>;
-    constraints?: {
-        allowedMcpServers?: string[];
-        allowedHosts?: string[];
-        allowedCommands?: string[];
-    };
-    exceptions: Array<{
-        scope: "company" | "user" | "source" | "repository" | "tool" | "category";
-        scopeValue: string;
-    }>;
-    fetchedAt: number;
-    signature?: {
-        algorithm: "Ed25519";
-        keyId: string;
-        signedAt: number;
-        value: string;
-    };
-}
-export interface LocalSecurityDecision {
-    action: LocalSecurityAction;
-    category?: SecurityCategory;
-    reason?: string;
-}
-export declare function withEndpointIdentity(event: SecurityWorkflowEvent, identity: {
-    endpointId?: string;
-    endpointName?: string;
-    cliVersion?: string;
-}): SecurityWorkflowEvent;
-/**
- * Runs before a user prompt reaches the model. This is intentionally narrow:
- * block credential material, but allow safe references such as
- * `$OPENAI_API_KEY` so developers can ask agents to use environment variables
- * without pasting their values.
- */
-export declare function evaluatePromptSecurity(prompt: string | undefined, policy?: EndpointSecurityPolicy, source?: AgentSurface): LocalSecurityDecision;
-/** Runs synchronously before a tool executes. No network or model is involved. */
-export declare function evaluateToolSecurity(input: RawSecurityHookInput, phase: SecurityHookPhase, policy?: EndpointSecurityPolicy, source?: AgentSurface, sessionContext?: {
-    sensitiveReadAt?: number;
-    now?: number;
-}): LocalSecurityDecision;
-export declare function securityInputHasSensitivePath(input: RawSecurityHookInput): boolean;
-export declare function buildSecurityWorkflowEvent(input: RawSecurityHookInput, phase: SecurityHookPhase, source: AgentSurface, now?: () => number): SecurityWorkflowEvent | null;
-/**
- * Captures the intent side of the causal chain without weakening the local
- * privacy boundary. A prompt that the deterministic policy blocks never
- * becomes an uploadable event; allowed prompts are redacted and bounded using
- * the same sanitizer as tool payloads.
- */
-export declare function buildSecurityPromptEvent(input: Pick<RawSecurityHookInput, "session_id" | "sessionId" | "cwd" | "prompt">, source: AgentSurface, now?: () => number, policy?: EndpointSecurityPolicy): SecurityWorkflowEvent | null;
-/** Audit-safe evidence for a blocked prompt. The secret-bearing prompt is
- * intentionally omitted; administrators still see that prevention occurred. */
-export declare function buildBlockedSecurityPromptEvent(input: Pick<RawSecurityHookInput, "session_id" | "sessionId" | "cwd">, source: AgentSurface, category: NonNullable<LocalSecurityDecision["category"]>, now?: () => number): SecurityWorkflowEvent | null;