codiedev 0.9.51 → 0.9.53

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,7 +82,9 @@ exports.cleanupVSCodeMcp = cleanupVSCodeMcp;
 exports.cleanupCodexMcp = cleanupCodexMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
+exports.ensureCodexLimitHookInstalled = ensureCodexLimitHookInstalled;
 exports.installCursorHook = installCursorHook;
+exports.ensureCursorCodiedevHooksInstalled = ensureCursorCodiedevHooksInstalled;
 exports.parseClaudeSteering = parseClaudeSteering;
 exports.parseCodexSteering = parseCodexSteering;
 exports.parseSteering = parseSteering;
@@ -99,6 +100,8 @@ exports.dispatchDeferredUpload = dispatchDeferredUpload;
 exports.sweepPendingCaptures = sweepPendingCaptures;
 exports.resolveCaptureFinal = resolveCaptureFinal;
 exports.finishInputTmpFile = finishInputTmpFile;
+exports.captureUploadTmpFile = captureUploadTmpFile;
+exports.cancelDeferredCaptureUpload = cancelDeferredCaptureUpload;
 exports.decideDispatch = decideDispatch;
 exports.readSessionUploadState = readSessionUploadState;
 exports.writeSessionUploadState = writeSessionUploadState;
@@ -109,6 +112,7 @@ exports.readLastCapture = readLastCapture;
 exports.runCaptureUpload = runCaptureUpload;
 exports.runDeferredUpload = runDeferredUpload;
 exports.transcriptReadSkipReason = transcriptReadSkipReason;
+exports.shouldReportCaptureSkip = shouldReportCaptureSkip;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -852,7 +856,7 @@ function buildCapturePayload(input) {
         sessionStartedAt: input.sessionStartedAt ?? undefined,
         interruptCount: input.interruptCount,
         rejectionCount: input.rejectionCount,
-        // final is only emitted when explicitly set (not for Codex/Cursor).
+        // final is only emitted when explicitly set (not for Codex).
         final: input.final,
         costUsd: input.costUsd,
     };
@@ -1052,15 +1056,11 @@ 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 +1069,9 @@ 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,47 +1085,17 @@ 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` +
+        `function invokeSync(invocation, payload) {\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` +
+        `    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` +
+        `    return JSON.parse(result.stdout || "{}");\n` +
+        `  } catch { return null; }\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` +
@@ -1139,27 +1103,16 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `  return ({\n` +
         `  "chat.message": async (input, output) => {\n` +
         `    const id = input?.sessionID ?? input?.sessionId ?? "unknown";\n` +
-        `    const cwd = await resolveCwd(id);\n` +
+        `    const cwd = worktree || directory || process.cwd();\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` +
+        `    const decision = invokeSync(PROMPT, { session_id: id, cwd, prompt });\n` +
+        `    const context = decision?.hookSpecificOutput?.additionalContext;\n` +
+        `    if (context && Array.isArray(output?.parts)) output.parts.push({ type: "text", text: context });\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 +1121,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 +1140,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` +
@@ -1214,7 +1165,7 @@ function vscodeCopilotInstalled() {
         return false;
     }
 }
-// Idempotently put a single codiedev hook (matcher ".*", running our hook.js
+// Idempotently put a single codiedev hook (matcher ".*" by default, running our hook.js
 // with `subcommand`) into the given hook event, stripping any prior codiedev
 // entries first so connect re-runs / upgrades refresh the resolved binary path.
 // Mutates `hooks` in place. Exported for unit testing.
@@ -1246,41 +1197,12 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
         return !(0, detection_1.isCodiedevHookCommand)(hook.matcher);
     });
     filtered.push({
-        matcher,
+        ...(matcher === null ? {} : { matcher }),
         hooks: [{ type: "command", command: resolveHookCommand(subcommand, preservedNodePath) }],
     });
     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 +1219,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 +1320,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 +1333,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) {
@@ -1512,7 +1413,6 @@ thought, use the \`codiedev\` CLI via Bash:**
 | "note that X is a follow-up" / "remember X" | \`codiedev note "<text>"\` |
 | "promote the extracted spec" | \`codiedev promote <artifact-id>\` |
 | "create a ticket" / "scope this into tickets" / "ticket this for me" | \`codiedev create-ticket [optional-inline-prompt]\` |
-| "post this to the team" / "publish to the feed" / "share with the team" | \`codiedev post --title "<t>" --body "<b>" [--intent <intent>] [--filename <key>] [--mention <name>]\` |
 | "share with a teammate" / "give someone access" (no notification) | \`codiedev share <key> <name> [--role read\\|edit]\` |
 | "send this to a teammate" / "ask someone to look at this" | \`codiedev send <key> <name> ["<msg>"]\` |
 | "find something about X" / "has anyone solved Y?" | \`codiedev search "<query>" [--limit N]\` |
@@ -1546,31 +1446,6 @@ read it back to the user so they can confirm.
 **Teammate names:** first name usually works (\`codiedev ping <name> ...\`).
 If ambiguous, the CLI returns candidates — retry with the full email.
 
-**Feed posts (broad team reach):** use \`codiedev post\` when the user
-wants visibility beyond one teammate — e.g., announcing a new skill,
-asking the team who knows about X, proposing a change. Always pass
-\`--intent\` to match the request: \`share\` (here's a skill),
-\`request_review\`, \`request_expertise\` (stuck, who knows this),
-\`link_share\` (fyi), or \`rfc\` (proposing a change). Pass \`--filename\`
-to link a specific artifact and \`--mention <name>\` (repeatable) to
-tag teammates.
-
-**Default feed-post shape.** When the user explicitly says "push/share/post
-to the feed", default to this shape unless they ask for something else:
-- **Title** ≤10 words: *what + why now*. Imperative or declarative — never
-  "Check this out".
-- **Body** — three short lines, grounded in the current session and the
-  artifact:
-  - **Why this exists** — 1–2 sentences from session context (the problem
-    or insight that produced the artifact).
-  - **What's in it** — 1 sentence pulled from the artifact's frontmatter
-    \`description:\` (skills) or first paragraph (specs). Don't restate
-    the whole file — the card preview carries the detail.
-  - **Ask** — 1 sentence. *Use it / review it / ping me with thoughts.*
-- **Filename**: always attach so the card preview renders.
-This is the default. If the user wants a one-liner or a different
-structure, follow their lead.
-
 **Search before pushing.** For any "save this as …" request, run
 \`codiedev search "<query>"\` first. If prior art exists, pull it and
 iterate rather than duplicating.
@@ -1874,7 +1749,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 +1764,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 +1774,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 +1803,59 @@ 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");
+    // Codex models UserPromptSubmit as a non-matcher event (the trust-key model
+    // intentionally excludes it from MATCHER_EVENTS), so omit the matcher key.
+    upsertCodiedevHook(hooks, "UserPromptSubmit", "discover-codex", null);
     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 newer lifecycle hooks 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 hasCommand = (entries, subcommand) => entries.some((group) => {
+            const record = group;
+            const flat = record.command;
+            if (typeof flat === "string" && flat.trim().endsWith(subcommand))
+                return true;
+            const inner = record.hooks;
+            return Array.isArray(inner) && inner.some((hook) => typeof hook.command === "string" && hook.command.trim().endsWith(subcommand));
+        });
+        let changed = false;
+        if (!hasCommand(stop, "limit-codex")) {
+            stop.unshift({
+                hooks: [{ type: "command", command: resolveHookCommand("limit-codex"), timeout: 10 }],
+            });
+            hooks.Stop = stop;
+            changed = true;
+        }
+        const promptEntries = Array.isArray(hooks.UserPromptSubmit)
+            ? hooks.UserPromptSubmit
+            : [];
+        if (!hasCommand(promptEntries, "discover-codex")) {
+            upsertCodiedevHook(hooks, "UserPromptSubmit", "discover-codex", null);
+            changed = true;
+        }
+        if (!changed)
+            return;
+        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
@@ -1965,25 +1881,61 @@ function installCursorHook() {
         hooksFile.hooks = {};
     }
     const hooks = hooksFile.hooks;
-    if (!hooks.sessionEnd) {
-        hooks.sessionEnd = [];
-    }
-    const existing = hooks.sessionEnd;
-    const filtered = existing.filter((h) => !(0, detection_1.isCodiedevHookCommand)(h.command));
-    filtered.push({
-        command: resolveHookCommand("capture-cursor"),
-        type: "command",
-        timeout: 30,
-    });
-    // sessionEnd → backup: auto-back-up changed artifact files to the private library.
-    filtered.push({
-        command: resolveHookCommand("backup"),
-        type: "command",
-        timeout: 30,
-    });
-    hooks.sessionEnd = filtered;
+    const replaceManaged = (eventName, subcommands) => {
+        const existing = Array.isArray(hooks[eventName])
+            ? hooks[eventName]
+            : [];
+        const preserved = existing.filter((hook) => !(0, detection_1.isCodiedevHookCommand)(hook.command));
+        const managed = subcommands.map((subcommand) => ({
+            command: resolveHookCommand(subcommand),
+            type: "command",
+            timeout: 30,
+        }));
+        if (preserved.length + managed.length === 0)
+            delete hooks[eventName];
+        else
+            hooks[eventName] = [...preserved, ...managed];
+    };
+    replaceManaged("sessionStart", ["session-start-cursor"]);
+    replaceManaged("sessionEnd", ["capture-cursor"]);
+    replaceManaged("stop", ["backup-cursor"]);
+    // Cursor cannot inject dynamic context from beforeSubmitPrompt today.
+    // Remove older Codiedev discovery entries so prompts are not uploaded for
+    // a response the host will discard; preserve any third-party hooks.
+    replaceManaged("beforeSubmitPrompt", []);
     fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
+function ensureCursorCodiedevHooksInstalled() {
+    try {
+        if (!fs.existsSync(CURSOR_HOOKS_PATH))
+            return;
+        const parsed = JSON.parse(fs.readFileSync(CURSOR_HOOKS_PATH, "utf8"));
+        const hooks = parsed.hooks ?? {};
+        const required = [
+            ["sessionStart", "session-start-cursor"],
+            ["sessionEnd", "capture-cursor"],
+            ["stop", "backup-cursor"],
+        ];
+        const has = (eventName, subcommand) => {
+            const entries = hooks[eventName];
+            return Array.isArray(entries) && entries.some((entry) => {
+                const command = entry.command;
+                return typeof command === "string"
+                    && (0, detection_1.isCodiedevHookCommand)(command)
+                    && command.trim().endsWith(subcommand);
+            });
+        };
+        const promptEntries = hooks.beforeSubmitPrompt;
+        const hasStalePromptHook = Array.isArray(promptEntries) && promptEntries.some((entry) => (0, detection_1.isCodiedevHookCommand)(entry.command));
+        if (!required.every(([eventName, subcommand]) => has(eventName, subcommand)) ||
+            hasStalePromptHook) {
+            installCursorHook();
+        }
+    }
+    catch {
+        // Best-effort repair only.
+    }
+}
 function parseClaudeSteering(content) {
     let interrupts = 0;
     let rejections = 0;
@@ -2598,18 +2550,21 @@ exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS + 2 * 60 * 1000;
 // hook with no subcommand) are a true final signal. capture-opencode/
 // capture-desktop (per-turn snapshot) and capture-opencode-final/
 // capture-desktop-final (real session end) get an explicit false/true.
-// Everything else — capture-codex (Codex's Stop fires per-turn; final:true
-// would close the server-side session lease every turn), capture-cursor, and
-// any FUTURE mode (e.g. a capture-windsurf added to resolveMode but not
-// audited here) — gets undefined, i.e. legacy server behaviour. Defaulting
-// unknowns to true would silently re-introduce the per-turn lease-close bug
-// for every new agent.
+// Cursor's capture-cursor is wired only to sessionEnd, so it is also a true
+// final signal. Everything else — capture-codex (Codex's Stop fires per-turn;
+// final:true would close the server-side session lease every turn) and any
+// FUTURE mode (e.g. a capture-windsurf added to resolveMode but not audited
+// here) — gets undefined, i.e. legacy server behaviour. Defaulting unknowns
+// to true would silently re-introduce the per-turn lease-close bug for every
+// new agent.
 function resolveCaptureFinal(argv2) {
     if (argv2 === "capture-opencode" || argv2 === "capture-desktop")
         return false;
     if (argv2 === "capture-opencode-final" || argv2 === "capture-desktop-final")
         return true;
-    return argv2 === "capture" || argv2 === undefined ? true : undefined;
+    return argv2 === "capture" || argv2 === "capture-cursor" || argv2 === undefined
+        ? true
+        : undefined;
 }
 // Build a UNIQUE finish-input tmpFile name per dispatch. Both the Stop hook and
 // SessionEnd dispatch capture-finish children, and the child unlinks its input
@@ -2622,7 +2577,29 @@ function resolveCaptureFinal(argv2) {
 // negligible volume (one tiny JSON per crashed child), though note Windows
 // %TEMP% is not auto-cleaned — acceptable.
 function finishInputTmpFile(sessionId) {
-    return path.join(os.tmpdir(), `codiedev-finish-${sessionId ?? process.pid}-${process.pid}-${Date.now()}.json`);
+    const safeId = String(sessionId ?? process.pid).replace(/[^A-Za-z0-9._-]/g, "_");
+    return path.join(os.tmpdir(), `codiedev-finish-${safeId}-${process.pid}-${Date.now()}.json`);
+}
+function captureUploadTmpFile(sessionId, mode, pid = process.pid, now = Date.now()) {
+    const id = String(sessionId ?? pid).replace(/[^A-Za-z0-9._-]/g, "_");
+    return path.join(os.tmpdir(), mode === "immediate"
+        ? `codiedev-capture-${id}-${pid}-${now}.json`
+        : `codiedev-capture-${id}.json`);
+}
+// Best-effort cancellation for a scheduled per-turn upload when a real final
+// capture arrives. Deferred jobs deliberately share one canonical filename;
+// removing it makes every sleeping uploader lose its later claim-by-rename.
+// The backend's capturedAt guard covers the narrow race where a child claimed
+// the file immediately before this unlink.
+function cancelDeferredCaptureUpload(sessionId, deps = fs) {
+    try {
+        deps.unlinkSync(captureUploadTmpFile(sessionId, "deferred"));
+        return true;
+    }
+    catch {
+        // Missing means there was nothing pending (or another process won).
+        return false;
+    }
 }
 // Decide whether to upload immediately or defer until the throttle window expires.
 //   final=true  → always immediate (SessionEnd: close the session now)
@@ -2787,14 +2764,6 @@ async function runCaptureUpload(jobFile, deps) {
             const { storageId } = await deps.uploadBytes(uploadUrl, Buffer.from(transcript, "base64"), "application/json");
             body = { ...body, transcriptStorageId: storageId };
             delete body.transcript;
-            // Persist the storage id before the metadata POST. Previously a failed
-            // captureSession request retried the entire direct upload, creating one
-            // unreferenced raw transcript blob per attempt. Once the PUT succeeds,
-            // every retry must reuse that exact blob.
-            job.body = body;
-            if (deps.writeFileSync) {
-                deps.writeFileSync(jobFile, JSON.stringify(job), { mode: 0o600 });
-            }
         }
         await deps.post(job.url, body, job.token);
         // success — drop a "last session captured" breadcrumb (before removing the
@@ -2947,3 +2916,9 @@ function transcriptReadSkipReason(err) {
         return "no-transcript";
     return `transcript-unreadable:${code || "unknown"}`;
 }
+// Per-turn snapshots are backups, not session endings. Reporting their local
+// read/empty condition as a session skip would hide or close coverage while the
+// agent is still running; only final/legacy capture paths emit the skip ping.
+function shouldReportCaptureSkip(final) {
+    return final !== false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.51",
+  "version": "0.9.53",
   "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,9 +12,9 @@
     "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:opencode-attribution": "vitest run src/__tests__/repoResolver.test.ts src/__tests__/openCodeCapture.test.ts src/__tests__/openCodePluginGitRefs.test.ts src/__tests__/capturePayloadFinal.test.ts src/__tests__/captureDirectUpload.test.ts src/__tests__/resolveCaptureFinal.test.ts && tsc",
+    "test:functional": "vitest run src/__tests__/limitEvent.functional.test.ts src/__tests__/harnessParity.functional.test.ts src/__tests__/cursorParity.functional.test.ts",
+    "test:harness-parity": "vitest run src/__tests__/harnessParity.functional.test.ts src/__tests__/cursorParity.functional.test.ts",
+    "test:harness-binaries": "node scripts/checkHarnessBinaries.mjs",
     "test:watch": "vitest"
   },
   "files": [
@@ -38,18 +38,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/codieStartup.d.ts

@@ -1,24 +0,0 @@
-import type { AgentSurface, EndpointSecurityPolicy } from "./security";
-import type { AgentSecurityEntitlement } from "./securityFeature";
-export interface CodieStartupConfig extends AgentSecurityEntitlement {
-    backendUrl?: string;
-    token?: string;
-    companyId?: string;
-}
-export type CodiePolicyRefreshResult = {
-    status: "disabled";
-} | {
-    status: "synced";
-    policy: EndpointSecurityPolicy;
-} | {
-    status: "cached";
-    error: string;
-};
-/** Refresh the endpoint policy before Codie hands the terminal to OpenCode.
- * Enforcement remains available offline because hooks keep using the last
- * verified company-scoped policy when this best-effort refresh cannot land. */
-export declare function refreshCodieSecurityPolicy(config: CodieStartupConfig, syncPolicy?: (config: {
-    backendUrl: string;
-    token: string;
-    companyId: string;
-}, source?: AgentSurface) => Promise<EndpointSecurityPolicy>): Promise<CodiePolicyRefreshResult>;