codiedev 0.10.0-beta.1 → 0.10.0-beta.11

package/dist/hook.js

@@ -35,31 +35,34 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDiscoveryContext = buildDiscoveryContext;
+const captureSignals_1 = require("./captureSignals");
+const transcriptModels_1 = require("./transcriptModels");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
 const limitEventReporter_1 = require("./limitEventReporter");
+const limitEvent_1 = require("./limitEvent");
+const cursorLifecycle_1 = require("./cursorLifecycle");
+const codexLimitScan_1 = require("./codexLimitScan");
+const launchContext_1 = require("./launchContext");
+const selfUpdate_1 = require("./selfUpdate");
 const version_1 = require("./version");
+const sync_1 = require("./packs/sync");
 const captureLog_1 = require("./captureLog");
-const security_1 = require("./security");
-const securitySession_1 = require("./securitySession");
-const securityPolicy_1 = require("./securityPolicy");
-const securityFeature_1 = require("./securityFeature");
-const securityInventory_1 = require("./securityInventory");
+const subagents_1 = require("./subagents");
 const captureExclusions_1 = require("./captureExclusions");
 const cursorHooks_1 = require("./cursorHooks");
-// Pure builder for the discovery additionalContext. Returns null when there are
-// no matches. The suggested `codiedev pull` command carries the EXACT top key
-// (e.g. "pr-push.md") rather than a "<key>" placeholder — otherwise agents
-// paraphrase the key (pr-push) and the extension-sensitive `pull` 404s.
+const copilotHooks_1 = require("./copilotHooks");
+const piHooks_1 = require("./piHooks");
+const cliSession_1 = require("./cliSession");
+const utils_2 = require("./utils");
 function buildDiscoveryContext(skills) {
     if (skills.length === 0)
         return null;
-    // Don't trust the API's ordering — rank by score so the suggested pull key is
-    // always the highest-confidence match.
     const top = [...skills].sort((a, b) => b.score - a.score).slice(0, 3);
     const lines = top
         .map((s) => `- ${s.key} — ${(s.score * 100).toFixed(0)}% match`)
@@ -71,31 +74,27 @@ function buildDiscoveryContext(skills) {
         "`. It encodes the team's vetted " +
         "approach. Skip it only if it clearly doesn't apply.");
 }
-// UserPromptSubmit: query skill discovery for the prompt and, if a team skill
-// clears the confidence threshold, inject it as additionalContext so the agent
-// can offer to pull+run it. Fully silent on miss/error — never blocks input.
-async function runDiscover(prompt) {
+async function discoverContext(prompt) {
     if (!prompt || !prompt.trim())
-        process.exit(0);
+        return null;
     const config = (0, utils_1.readConfig)();
     if (!config)
-        process.exit(0);
+        return null;
     try {
-        // POST body, never a query param: raw prompts in GET query strings land
-        // in server/proxy access logs (SIG-16). The server keeps accepting legacy
-        // GETs from older CLIs during the transition.
         const res = await postJsonForResponse(`${config.backendUrl}/api/cli/skill-discovery`, { q: prompt }, config.token);
         const skills = res?.skills ?? [];
-        const additionalContext = buildDiscoveryContext(skills);
-        if (additionalContext) {
-            process.stdout.write(JSON.stringify({
-                hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext },
-            }));
-        }
+        return buildDiscoveryContext(skills);
     }
     catch {
-        // silent — discovery is best-effort
     }
+    return null;
+}
+async function runDiscover(prompt) {
+    const additionalContext = await discoverContext(prompt);
+    if (additionalContext)
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext },
+        }));
     process.exit(0);
 }
 function readTranscriptTailFile(transcriptPath, maxBytes = 512 * 1024) {
@@ -112,9 +111,6 @@ function readTranscriptTailFile(transcriptPath, maxBytes = 512 * 1024) {
         fs.closeSync(handle);
     }
 }
-// StopFailure (matcher rate_limit): the dev just got blocked. Read the local
-// transcript tail for the ground-truth rate_limit line and POST a tiny event.
-// Best-effort + silent — StopFailure output is ignored by Claude Code anyway.
 async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
     const config = (0, utils_1.readConfig)();
     if (!config)
@@ -123,12 +119,9 @@ async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
     const tp = hookInput.transcript_path;
     if (tp) {
         try {
-            // Codex invokes Stop after every turn. Bound this read so long-running
-            // sessions do not repeatedly load their entire rollout into memory.
             transcript = readTranscriptTailFile(tp);
         }
         catch {
-            /* unreadable transcript — fall through to minimal event */
         }
     }
     try {
@@ -141,21 +134,81 @@ async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
         });
     }
     catch {
-        /* best-effort */
     }
 }
 async function runStopFailure(hookInput) {
     await readAndPostLimitEvent(hookInput, "claude-code", true);
     process.exit(0);
 }
+async function reportCodexLimitFromFile(config, transcriptPath, sessionId) {
+    const hit = (0, codexLimitScan_1.scanCodexRolloutForLimit)(transcriptPath);
+    if (!hit)
+        return false;
+    await (0, limitEventReporter_1.postLimitEvent)(config, {
+        source: "codex",
+        ...hit.event,
+        sessionId: sessionId ?? (0, codexLimitScan_1.sessionIdFromRolloutPath)(transcriptPath),
+        transcriptTail: (0, codexLimitScan_1.readTailEndingAt)(transcriptPath, hit.lineEnd),
+    });
+    (0, codexLimitScan_1.recordCodexLimitReported)(transcriptPath, hit.event.at);
+    return true;
+}
 async function runCodexLimit(hookInput) {
-    await readAndPostLimitEvent(hookInput, "codex", false);
+    const config = (0, utils_1.readConfig)();
+    const transcriptPath = hookInput.transcript_path;
+    if (config && transcriptPath) {
+        try {
+            const sent = await reportCodexLimitFromFile(config, transcriptPath, hookInput.session_id);
+            if (sent) {
+                (0, captureLog_1.appendCaptureLog)({
+                    stage: "limit",
+                    sessionId: hookInput.session_id,
+                    outcome: "ok",
+                    detail: "source=codex trigger=stop",
+                });
+            }
+        }
+        catch (err) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "limit",
+                sessionId: hookInput.session_id,
+                outcome: "ERROR",
+                detail: `source=codex trigger=stop ${err.message}`,
+            });
+        }
+    }
     process.exit(0);
 }
-// Skip-reason ping: this session is ending WITHOUT a capture, and here's why.
-// Turns silent coverage loss into per-reason buckets on the admin Capture
-// Health panel (patches the session's aiSessionStarts row server-side). Tiny
-// like the sessionStart ping. Best-effort, never throws.
+const PROMPT_LIMIT_POST_TIMEOUT_MS = 2_500;
+async function runCodexLimitSweep(sessionId) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        return;
+    try {
+        const posted = await (0, codexLimitScan_1.sweepCodexLimits)({
+            sessionsDir: (0, codexLimitScan_1.codexSessionsDir)(),
+            post: (payload) => (0, limitEventReporter_1.postLimitEvent)(config, payload, PROMPT_LIMIT_POST_TIMEOUT_MS),
+            findOptions: { withinMs: 24 * 3600_000 },
+            scanOptions: { maxScanBytes: 4 * 1024 * 1024 },
+        });
+        if (posted > 0) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "limit",
+                sessionId,
+                outcome: "ok",
+                detail: `source=codex trigger=prompt events=${posted}`,
+            });
+        }
+    }
+    catch (err) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "limit",
+            sessionId,
+            outcome: "ERROR",
+            detail: `source=codex trigger=prompt ${err.message}`,
+        });
+    }
+}
 async function postSessionSkip(config, sessionId, reason) {
     if (!sessionId)
         return;
@@ -163,17 +216,12 @@ async function postSessionSkip(config, sessionId, reason) {
         await postJson(`${config.backendUrl}/api/cli/sessionSkip`, { sessionId, reason, at: Date.now() }, config.token, PING_TIMEOUT_MS);
     }
     catch {
-        /* best-effort */
     }
 }
-// SessionStart: the capture-coverage denominator. Record that a session opened
-// so the backend can later compute captured ÷ started. Deliberately tiny — no
-// transcript read, no git — so it never slows session startup. Best-effort +
-// silent (SessionStart hook output is ignored by Claude Code).
 async function runSessionStart(hookInput, source = "claude-code") {
     const config = (0, utils_1.readConfig)();
     if (!config)
-        process.exit(0);
+        return;
     if (hookInput.session_id) {
         try {
             await postJson(`${config.backendUrl}/api/cli/sessionStart`, {
@@ -183,18 +231,11 @@ async function runSessionStart(hookInput, source = "claude-code") {
             }, config.token, PING_TIMEOUT_MS);
         }
         catch {
-            /* best-effort — never block session startup */
         }
     }
-    process.exit(0);
+    return;
 }
-function postJson(url, body, bearerToken, 
-// Socket timeout. Pass a SMALL value for tiny pings that run on (or near)
-// Claude Code's shutdown clock — a black-holed connection (proxy dropping
-// packets without RST) otherwise hangs the hook until CC kills it. Leave
-// unset for transcript uploads, which legitimately take a while on slow
-// corporate links and already run in detached children with retry.
-timeoutMs) {
+function postJson(url, body, bearerToken, timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -235,9 +276,6 @@ timeoutMs) {
         req.end();
     });
 }
-// postJson variant that returns the parsed response body — the upload-URL
-// handshake needs the { uploadUrl } the server hands back. No timeout: runs
-// only in detached uploader children, never on the shutdown clock.
 function postJsonForResponse(url, body, bearerToken, timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -281,138 +319,6 @@ function postJsonForResponse(url, body, bearerToken, timeoutMs) {
         req.end();
     });
 }
-// Local policy runs synchronously before a tool executes. Workflow telemetry
-// is dispatched separately and fail-open, so a detector outage or timeout can
-// never delay or override the deterministic endpoint decision.
-async function runSecurityHook(hookInput, phase, source, uploadTelemetry = true) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const policy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
-    const sessionId = hookInput.session_id ?? hookInput.sessionId;
-    const sessionSignal = phase === "pre" ? (0, securitySession_1.readSessionSecuritySignal)(sessionId) : undefined;
-    const localDecision = (0, security_1.evaluateToolSecurity)(hookInput, phase, policy, source, sessionSignal);
-    if (phase === "post" && (0, security_1.securityInputHasSensitivePath)(hookInput)) {
-        (0, securitySession_1.recordSensitiveReadSignal)(sessionId);
-    }
-    const event = (0, security_1.buildSecurityWorkflowEvent)(hookInput, phase, source);
-    if (event) {
-        event.localDecision = localDecision.action;
-        event.localCategory = localDecision.category;
-    }
-    if (localDecision.action === "block" && phase === "pre") {
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
-            outcome: "ok",
-            detail: `phase=${phase} localDecision=block category=${localDecision.category}`,
-        });
-        if (uploadTelemetry)
-            dispatchSecurityEventUpload(event);
-        const response = source === "cursor"
-            ? (0, cursorHooks_1.cursorPreToolBlockResponse)(localDecision.reason ?? "Codie blocked this action")
-            : {
-                hookSpecificOutput: {
-                    hookEventName: "PreToolUse",
-                    permissionDecision: "deny",
-                    permissionDecisionReason: localDecision.reason,
-                },
-            };
-        process.stdout.write(JSON.stringify(response));
-        return;
-    }
-    if (!event)
-        return;
-    if (uploadTelemetry)
-        dispatchSecurityEventUpload(event);
-}
-function runPromptSecurityHook(hookInput, source, uploadTelemetry = true) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return false;
-    const decision = (0, security_1.evaluatePromptSecurity)(hookInput.prompt, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId), source);
-    if (decision.action !== "block")
-        return false;
-    (0, captureLog_1.appendCaptureLog)({
-        stage: "security",
-        sessionId: hookInput.session_id ?? hookInput.sessionId ?? "unknown",
-        outcome: "ok",
-        detail: `phase=prompt localDecision=block category=${decision.category} telemetry=${uploadTelemetry ? "enabled" : "suppressed"} cwd=${hookInput.cwd ?? "unknown"}`,
-    });
-    if (uploadTelemetry) {
-        dispatchSecurityEventUpload((0, security_1.buildBlockedSecurityPromptEvent)(hookInput, source, decision.category ?? "secret_in_prompt"));
-    }
-    const response = source === "cursor"
-        ? (0, cursorHooks_1.cursorPromptBlockResponse)(decision.reason ?? "Codie blocked this prompt")
-        : { decision: "block", reason: decision.reason };
-    process.stdout.write(JSON.stringify(response));
-    return true;
-}
-function dispatchAllowedPromptSecurityEvent(hookInput, source) {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const event = (0, security_1.buildSecurityPromptEvent)(hookInput, source, Date.now, (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId));
-    if (event)
-        dispatchSecurityEventUpload(event);
-}
-function dispatchSecurityEventUpload(event) {
-    if (!event || !(0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()))
-        return;
-    try {
-        const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-upload"], {
-            detached: true,
-            stdio: ["pipe", "ignore", "ignore"],
-        });
-        child.stdin?.end(JSON.stringify(event));
-        child.unref();
-    }
-    catch {
-        // Telemetry is best-effort and must never delay local enforcement.
-    }
-}
-async function runSecurityEventUpload() {
-    const config = (0, utils_1.readConfig)();
-    if (!config || !(0, securityFeature_1.isAgentSecurityEnabled)(config))
-        return;
-    const startedAt = Date.now();
-    try {
-        const raw = await readStdin();
-        const event = JSON.parse(raw);
-        const cachedPolicy = (0, securityPolicy_1.readEndpointSecurityPolicy)(undefined, undefined, config.companyId);
-        const eventWithEndpoint = (0, security_1.withEndpointIdentity)(event, {
-            endpointId: config.deviceId,
-            endpointName: config.deviceName,
-            cliVersion: version_1.CLI_VERSION,
-            securityRuntimeVersion: security_1.SECURITY_RUNTIME_VERSION,
-            securityPolicyVersion: cachedPolicy?.policyVersion,
-        });
-        const result = await postJsonForResponse(`${config.backendUrl}/api/cli/securityEvent`, { ...eventWithEndpoint }, config.token, 
-        // Leave room for a cold backend and durable scheduling. This uploader is
-        // detached, so the network budget never delays the developer's prompt or
-        // tool call. Policy refreshes use the separately signed sync endpoint.
-        5_000);
-        if (result?.policy?.schemaVersion === 1) {
-            (0, securityPolicy_1.writeEndpointSecurityPolicy)(result.policy, undefined, undefined, config.companyId);
-        }
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: event.sessionId,
-            outcome: "ok",
-            detail: `phase=${event.phase} elapsedMs=${Date.now() - startedAt} verdict=${String(result?.verdict ?? "unknown")}`,
-        });
-    }
-    catch (err) {
-        (0, captureLog_1.appendCaptureLog)({
-            stage: "security",
-            sessionId: "upload",
-            outcome: "ERROR",
-            detail: `elapsedMs=${Date.now() - startedAt} ${err.message}`,
-        });
-    }
-}
-// Raw-bytes POST to a Convex storage upload URL (no auth header — the URL
-// itself is the one-time credential). Returns the parsed { storageId }.
 function postBytes(url, bytes, contentType) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -448,9 +354,6 @@ function postBytes(url, bytes, contentType) {
         req.end();
     });
 }
-// Short leash for the tiny coverage pings (sessionStart / sessionSkip): they
-// carry a few bytes and must never stall a hook. 3s is generous for a ping
-// and a hard bound for the shutdown clock.
 const PING_TIMEOUT_MS = 3000;
 async function readStdin() {
     return new Promise((resolve, reject) => {
@@ -468,50 +371,35 @@ function resolveMode(arg) {
         return "codex";
     if (arg === "capture-cursor" || arg === "backup-cursor")
         return "cursor";
+    if (arg === "capture-copilot" || arg === "backup-copilot")
+        return "copilot";
     if (arg === "capture-opencode" || arg === "capture-opencode-final")
         return "opencode";
+    if (arg === "capture-pi" || arg === "capture-pi-final")
+        return "pi";
     if (arg === "capture-desktop" || arg === "capture-desktop-final")
         return "desktop";
     return "claude-code";
 }
 async function main() {
-    // Shared upload deps used by both "upload" and "upload-deferred" branches.
-    // Extracted to keep both branches in lockstep — any new dep added here
-    // automatically applies to the deferred path too.
+    await (0, cliSession_1.ensureFreshToken)({ configPath: utils_2.CONFIG_PATH }).catch(() => undefined);
     function makeUploadDeps() {
         return {
             post: postJson,
-            // Direct-to-storage flow for big transcripts (see utils.ts
-            // DIRECT_UPLOAD_THRESHOLD_CHARS): fetch a one-time upload URL, then
-            // POST the raw bytes to it. Keeps ~7MB+ transcripts out of the
-            // backend's 64MB captureSession isolate.
             requestJson: postJsonForResponse,
             uploadBytes: postBytes,
             readFileSync: fs.readFileSync,
             unlinkSync: fs.unlinkSync,
-            // Persist a bumped attempt count on failure so a later sweep retries
-            // (instead of dropping a session on a transient network blip).
             writeFileSync: fs.writeFileSync,
-            // On a successful upload, drop the "last session captured" breadcrumb
-            // that `codiedev doctor` reads to confirm the session landed.
             recordSuccess: (job) => (0, utils_1.writeLastCapture)((0, utils_1.buildLastCaptureRecord)(job, Date.now())),
-            // Write structured outcome lines (ok / ERROR / gave-up) to the
-            // rotating capture log so users and doctor can see why captures fail.
             log: (e) => (0, captureLog_1.appendCaptureLog)(e),
-            // Write per-session upload state so the throttle can defer later
-            // non-final uploads within the same window.
             writeSessionState: utils_1.writeSessionUploadState,
-            // Re-read local config in the uploader so adding an exclusion after a
-            // job was queued still prevents its transcript from leaving the device.
             shouldSkipJob: (job) => {
                 const config = (0, utils_1.readConfig)();
                 return (0, captureExclusions_1.shouldSkipCaptureUploadJob)(job, config);
             },
         };
     }
-    // Detached uploader child (spawned by the capture path below). The job —
-    // including transcript and token — is on disk; no stdin is needed, so handle
-    // this before readStdin() to avoid blocking on the ignored stdin pipe.
     if (process.argv[2] === "upload") {
         const jobFile = process.argv[3];
         if (jobFile) {
@@ -519,10 +407,6 @@ async function main() {
         }
         process.exit(0);
     }
-    // Deferred uploader child (spawned by runCaptureFinish when the per-turn
-    // Stop capture is inside the throttle window). Sleeps for the remaining
-    // delay, then claims the job file (if it hasn't been superseded by a newer
-    // turn) and uploads. No stdin needed — handle before readStdin().
     if (process.argv[2] === "upload-deferred") {
         const jobFile = process.argv[3];
         const delayMs = Math.max(0, Number(process.argv[4]) || 0);
@@ -534,35 +418,11 @@ async function main() {
         }
         process.exit(0);
     }
-    // Daily component drift scan runs in a detached hook process. The parent
-    // SessionStart path only performs a timestamp read, so agent startup never
-    // waits for filesystem traversal or an inventory upload.
-    if (process.argv[2] === "security-inventory-upload") {
-        const config = (0, utils_1.readConfig)();
-        if (config && (0, securityFeature_1.isAgentSecurityEnabled)(config)) {
-            const inventory = (0, securityInventory_1.buildSecurityInventory)({ workspace: process.argv[3] || process.cwd() });
-            try {
-                await (0, securityInventory_1.uploadSecurityInventory)(inventory, config);
-            }
-            catch { /* retry after the daily inventory window */ }
-        }
-        process.exit(0);
-    }
-    // Detached backup uploader child (spawned by runBackup below). The job file
-    // carries only { root, files }; the child re-reads config from disk. No stdin
-    // needed, so handle it before readStdin() like the capture uploader above.
     if (process.argv[2] === "backup-upload") {
         const { runBackupUpload } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
         await runBackupUpload(process.argv[3]);
         process.exit(0);
     }
-    // Detached capture-finish child (spawned by the SessionEnd capture path
-    // below). The job carries only the raw hook inputs; this child does ALL the
-    // heavy work — read the transcript, parse it, resolve git branch/SHAs (the
-    // per-SHA `git rev-parse` calls that were overrunning CC's shutdown window
-    // on Windows), build the payload, and dispatch the upload. Running here means
-    // none of it is on the SessionEnd shutdown clock, so it can never be
-    // "Hook cancelled". No stdin needed — handle it before readStdin().
     if (process.argv[2] === "capture-finish") {
         const jobFile = process.argv[3];
         if (jobFile) {
@@ -571,26 +431,25 @@ async function main() {
                 await runCaptureFinish(job);
             }
             catch {
-                // best-effort — never throw out of the detached child
             }
             finally {
                 try {
                     fs.unlinkSync(jobFile);
                 }
                 catch {
-                    /* ignore */
                 }
             }
         }
         process.exit(0);
     }
-    // Detached, best-effort security telemetry. Local policy decisions have
-    // already completed in the parent hook; this child can never delay or alter
-    // the developer's action.
-    if (process.argv[2] === "security-upload") {
-        await runSecurityEventUpload();
+    if (process.argv[2] === "self-update") {
+        await (0, selfUpdate_1.runSelfUpdate)(process.argv[1]);
         process.exit(0);
     }
+    const migrated = process.env.CODIEDEV_VIA_LAUNCHER ? [] : (0, utils_1.migrateHooksToLauncher)();
+    if (migrated.length === 0)
+        (0, selfUpdate_1.maybeSpawnSelfUpdate)(process.argv[1]);
+    (0, selfUpdate_1.maybeRefreshInstructions)();
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -598,60 +457,65 @@ async function main() {
             const parsed = JSON.parse(raw);
             hookInput = (process.argv[2]?.endsWith("-cursor")
                 ? (0, cursorHooks_1.normalizeCursorHookInput)(parsed)
-                : parsed);
+                : process.argv[2]?.endsWith("-copilot")
+                    ? (0, copilotHooks_1.normalizeCopilotHookInput)(parsed)
+                    : parsed);
         }
     }
     catch {
         process.exit(0);
     }
-    // Privacy exclusions suppress every Codiedev upload, but they must never
-    // disable local security enforcement. Security hooks run first with telemetry
-    // disabled; all other hook modes still exit before making a network request.
-    const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
-    const securityCommand = process.argv[2] ?? "";
-    const securityMatch = securityCommand.match(/^security-(pre|post|failure)(?:-(codex|cursor|codie))?$/);
-    if (securityMatch) {
-        const source = securityMatch[2] === "codex"
-            ? "codex"
-            : securityMatch[2] === "cursor"
-                ? "cursor"
-                : securityMatch[2] === "codie"
-                    ? "codie-harness"
-                    : "claude-code";
-        await runSecurityHook(hookInput, securityMatch[1], source, !captureIgnored);
+    if (process.argv[2]?.startsWith("security-"))
         process.exit(0);
-    }
-    // UserPromptSubmit discovery path — separate from session capture.
+    const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
     const promptCommand = process.argv[2] ?? "";
-    if (promptCommand === "security-prompt-cursor") {
-        if (runPromptSecurityHook(hookInput, "cursor", !captureIgnored))
-            return;
-        if (captureIgnored)
-            return;
-        dispatchAllowedPromptSecurityEvent(hookInput, "cursor");
-        process.exit(0);
-    }
     if (process.argv[2] === "discover" ||
         process.argv[2] === "discover-codex" ||
-        process.argv[2] === "discover-codie") {
+        process.argv[2] === "discover-codie" ||
+        process.argv[2] === "discover-copilot" ||
+        process.argv[2] === "discover-pi") {
         const source = promptCommand === "discover-codex"
             ? "codex"
             : promptCommand === "discover-codie"
                 ? "codie-harness"
-                : "claude-code";
-        // Security runs first and locally. A blocked prompt is erased before it
-        // reaches the model, so discovery must not send it to the backend.
-        if (runPromptSecurityHook(hookInput, source, !captureIgnored))
-            return;
+                : promptCommand === "discover-copilot"
+                    ? "copilot"
+                    : promptCommand === "discover-pi"
+                        ? "pi"
+                        : "claude-code";
         if (captureIgnored)
             return;
-        dispatchAllowedPromptSecurityEvent(hookInput, source);
-        await runDiscover(hookInput.prompt);
+        if (source === "codex")
+            await runCodexLimitSweep(hookInput.session_id);
+        if (source === "codex")
+            (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
+        if (source !== "copilot")
+            await runDiscover(hookInput.prompt);
         return;
     }
     if (captureIgnored)
         process.exit(0);
-    // StopFailure (matcher rate_limit): post the rate-limit event.
+    if (["session-start-cursor", "backup-cursor", "capture-cursor", "observe-cursor"].includes(process.argv[2])) {
+        try {
+            (0, cursorLifecycle_1.recordCursorLifecycle)(hookInput, process.argv[2] === "capture-cursor");
+        }
+        catch { }
+    }
+    if (process.argv[2] === "observe-cursor") {
+        process.stdout.write("{}");
+        return;
+    }
+    if (process.argv[2] === "limit-copilot") {
+        const config = (0, utils_1.readConfig)();
+        const event = (0, limitEvent_1.parseNativeLimitError)(hookInput);
+        if (config && event) {
+            try {
+                await (0, limitEventReporter_1.postLimitEvent)(config, { ...event, source: "copilot", sessionId: hookInput.session_id });
+            }
+            catch { }
+        }
+        return;
+    }
     if (process.argv[2] === "limit") {
         await runStopFailure(hookInput);
         return;
@@ -660,109 +524,100 @@ async function main() {
         await runCodexLimit(hookInput);
         return;
     }
-    // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
     if (process.argv[2] === "session-start" ||
         process.argv[2] === "session-start-cursor" ||
-        process.argv[2] === "session-start-opencode") {
-        if ((0, securityFeature_1.isAgentSecurityEnabled)((0, utils_1.readConfig)()) && (0, securityInventory_1.securityInventoryDue)()) {
-            try {
-                const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], "security-inventory-upload", hookInput.cwd || process.cwd()], {
-                    detached: true,
-                    stdio: "ignore",
-                });
-                child.unref();
-            }
-            catch { /* daily inventory is best-effort */ }
-        }
+        process.argv[2] === "session-start-copilot" ||
+        process.argv[2] === "session-start-opencode" ||
+        process.argv[2] === "session-start-pi") {
+        (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
+        const packNag = process.argv[2] === "session-start-opencode" || process.argv[2] === "session-start-pi" ? null : (0, sync_1.packNagLine)();
+        if (packNag && process.argv[2] === "session-start")
+            process.stdout.write(`${packNag}\n`);
         await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
             ? "opencode"
             : process.argv[2] === "session-start-cursor"
                 ? "cursor"
-                : "claude-code");
+                : process.argv[2] === "session-start-copilot"
+                    ? "copilot"
+                    : process.argv[2] === "session-start-pi"
+                        ? "pi"
+                        : "claude-code");
+        if ((0, utils_1.readConfig)() && (process.argv[2] === "session-start-cursor" || process.argv[2] === "session-start-copilot")) {
+            const source = process.argv[2] === "session-start-cursor" ? "cursor" : "copilot";
+            const { TEAM_SKILL_CONTEXT, teamSkillSessionOutput } = await Promise.resolve().then(() => __importStar(require("./teamSkillContext")));
+            const prompt = hookInput.initialPrompt
+                ?? hookInput.initial_prompt;
+            const discovered = typeof prompt === "string" ? await discoverContext(prompt) : null;
+            process.stdout.write(JSON.stringify(teamSkillSessionOutput(source, [TEAM_SKILL_CONTEXT, discovered, packNag].filter(Boolean).join("\n\n"))));
+        }
         return;
     }
-    // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
-    // every codiedev hook — INCLUDING SessionEnd→capture, which previously had
-    // no self-heal and could stay stripped forever while SessionStart kept
-    // pinging (the Sonifi "starts arrive, captures never" loss) — re-wired on
-    // their next Stop/SessionEnd. One read + one write, only when missing.
     if ((process.argv[2] ?? "").endsWith("-cursor")) {
         (0, utils_1.ensureCursorCodiedevHooksInstalled)();
     }
+    else if ((process.argv[2] ?? "").endsWith("-copilot")) {
+        (0, utils_1.ensureCopilotCodiedevHooksInstalled)();
+    }
+    else if (/-pi(?:-final)?$/.test(process.argv[2] ?? "")) {
+        (0, utils_1.ensurePiExtensionInstalled)();
+    }
     else {
         (0, utils_1.ensureAllCodiedevHooksInstalled)();
     }
     if (process.argv[2] === "capture-codex")
         (0, utils_1.ensureCodexLimitHookInstalled)();
+    if (/-opencode(?:-final)?$/.test(process.argv[2] ?? ""))
+        (0, utils_1.ensureOpenCodePluginCurrent)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
+    const launch = (0, launchContext_1.hookLaunch)(process.argv[2], hookInput, {
+        copilotClientName: process.argv[2]?.endsWith("-copilot")
+            ? (0, copilotHooks_1.readCopilotWorkspace)(transcript_path).clientName
+            : undefined,
+    });
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
-    // Stop/sessionEnd backup path — separate from session capture and needs no
-    // transcript. Lists changed artifact files in the workspace and dispatches a
-    // detached child that backs them up privately. Best-effort, never blocks.
-    //
-    // Per-turn capture: Stop fires reliably in editor-embedded clients (VS Code
-    // extension) where SessionEnd may never come — the silent zero-capture bug.
-    // Same detached capture-finish child as SessionEnd, marked non-final so the
-    // server renews the session lease instead of summarizing immediately.
-    if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor") {
-        if (transcript_path) {
+    if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor" || process.argv[2] === "backup-copilot" || process.argv[2] === "backup-pi") {
+        if (transcript_path && !(0, utils_1.isCodexRolloutPath)(transcript_path)) {
             try {
                 (0, utils_1.dispatchCaptureFinish)({
-                    mode: process.argv[2] === "backup-cursor" ? "capture-cursor" : "capture",
+                    mode: process.argv[2] === "backup-cursor"
+                        ? "capture-cursor"
+                        : process.argv[2] === "backup-copilot"
+                            ? "capture-copilot"
+                            : process.argv[2] === "backup-pi"
+                                ? "capture-pi"
+                                : "capture",
                     session_id,
                     transcript_path,
                     cwd,
                     workspace_roots,
-                    // non-final: server should renew the lease, not close it yet.
+                    ...(launch ? { launch } : {}),
                     final: false,
                 }, process.argv[1], {
                     spawn: child_process_1.spawn,
                     writeFileSync: fs.writeFileSync,
                     openSync: fs.openSync,
                     closeSync: fs.closeSync,
-                    // UNIQUE per dispatch (sid+pid+ts): Stop and SessionEnd children
-                    // each own their input file exclusively — a shared per-session
-                    // name let one child's `finally` unlink eat the other's input
-                    // (lost final:true) or double-dispatch. See finishInputTmpFile.
                     tmpFile: (0, utils_1.finishInputTmpFile)(session_id),
                 });
             }
             catch {
-                // capture is best-effort; never break backup
             }
         }
         const { runBackup } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
         runBackup(workspaceRoot, process.argv[1]);
         process.exit(0);
     }
-    // Capture path (SessionEnd). Do the ABSOLUTE MINIMUM inline so this hook
-    // exits 0 within Claude Code's SessionEnd shutdown window: a cheap config /
-    // transcript guard, then hand ALL the heavy work (transcript read + parse +
-    // per-SHA `git rev-parse` + upload) to a detached `capture-finish` child.
-    // Detaching only the upload (the old #240 fix) left the synchronous parse and
-    // git work on the shutdown clock, which still overran on Windows — where each
-    // subprocess spawn costs ~50-150ms — producing "Hook cancelled" even though
-    // the data still landed. JS can't be interrupted mid-sync-chain, so the work
-    // finished and the upload went through, but CC had already given up waiting.
     const config = (0, utils_1.readConfig)();
     if (!config) {
-        // No config = no token; nothing can be sent, not even a skip ping.
         process.exit(0);
     }
     if (!transcript_path) {
-        // Nothing to capture — but say so, instead of leaving a start ping with
-        // no matching capture (silent coverage loss). One tiny POST; the rare
-        // no-transcript case has no other work on the shutdown clock.
         await postSessionSkip(config, session_id, "no-transcript-path");
         process.exit(0);
     }
     try {
-        // "codiedev-finish-" prefix (NOT "codiedev-capture-") so the sweep regex
-        // /^codiedev-capture-.*\.json$/ never mistakes a finish-input file for an
-        // upload job. UNIQUE per dispatch (sid+pid+ts) so a concurrent Stop-hook
-        // child's `finally` unlink can never eat this input (lost final:true).
         const jobFile = (0, utils_1.finishInputTmpFile)(session_id);
         (0, utils_1.dispatchCaptureFinish)({
             mode: process.argv[2] ?? "capture",
@@ -770,9 +625,7 @@ async function main() {
             transcript_path,
             cwd,
             workspace_roots,
-            // final:true for real SessionEnd signals (Claude Code and Cursor).
-            // Codex routes its per-turn Stop hook through "capture-codex" —
-            // final:true there would close the server lease every turn.
+            ...(launch ? { launch } : {}),
             final: (0, utils_1.resolveCaptureFinal)(process.argv[2]),
         }, process.argv[1], { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile: jobFile, openSync: fs.openSync, closeSync: fs.closeSync });
     }
@@ -781,19 +634,10 @@ async function main() {
     }
     process.exit(0);
 }
-// Runs inside the detached `capture-finish` child spawned by the SessionEnd
-// hook above. This is everything that used to run inline in main(): read the
-// transcript, resolve the repo, parse stats/usage/steering, resolve the git
-// branch + authored SHAs (the per-SHA `git rev-parse` calls that overran the
-// shutdown window on Windows), build the payload, and fire the upload from a
-// further-detached uploader. Running here means none of it is on the SessionEnd
-// shutdown clock, so it can never be "Hook cancelled". Best-effort throughout.
 async function runCaptureFinish(input) {
     const config = (0, utils_1.readConfig)();
     if (!config)
         return;
-    // Re-check in the detached child: the user may have added an exclusion
-    // after the parent hook dispatched this job but before it started.
     if ((0, captureExclusions_1.shouldIgnoreCaptureInput)(config, input)) {
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
@@ -808,8 +652,6 @@ async function runCaptureFinish(input) {
         await postSessionSkip(config, session_id, "no-transcript-path");
         return;
     }
-    // Log that this child has started processing — the first diagnostic proof
-    // that the detached capture-finish child actually ran (visible in doctor).
     (0, captureLog_1.appendCaptureLog)({ stage: "capture-finish", sessionId: session_id, outcome: "start" });
     try {
         await runCaptureFinishInner(input, config, session_id, transcript_path, cwd, workspace_roots);
@@ -825,10 +667,6 @@ async function runCaptureFinish(input) {
 }
 async function runCaptureFinishInner(input, config, session_id, transcript_path, cwd, workspace_roots) {
     const mode = resolveMode(input.mode);
-    // Desktop transcripts (opencode SDK {info,parts}[] dumps) are byte-identical
-    // to opencode's, so every parser below EXCEPT parseUsage treats desktop
-    // exactly as opencode via this mapping. parseUsage is the one exception —
-    // see the rawTranscriptContent note below.
     const parserMode = mode === "desktop" ? "opencode" : mode;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
@@ -837,11 +675,14 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
+        if (mode === "copilot" && input.final === true && !(0, copilotHooks_1.hasCopilotShutdown)(transcriptContent)) {
+            for (let waited = 0; waited < COPILOT_SHUTDOWN_WAIT_MS && !(0, copilotHooks_1.hasCopilotShutdown)(transcriptContent); waited += 250) {
+                await new Promise((resolve) => setTimeout(resolve, 250));
+                transcriptContent = fs.readFileSync(transcript_path, "utf8");
+            }
+        }
     }
     catch (err) {
-        // ENOENT → "no-transcript" (phantom desktop-app helper session, excluded
-        // from coverage server-side); anything else → "transcript-unreadable:<code>"
-        // (real transcript, read failed — a genuine, diagnosable loss).
         const reason = (0, utils_1.transcriptReadSkipReason)(err);
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
@@ -854,98 +695,93 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         }
         return;
     }
-    // Snapshot the RAW transcript before normalization below flattens it to
-    // Claude Code's newline-JSONL shape — that flattening drops info.cost /
-    // info.providerID, which desktop's parseUsage (below) needs and opencode's
-    // doesn't. Every other mode leaves transcriptContent untouched here, so this
-    // is a no-op for them.
     const rawTranscriptContent = transcriptContent;
+    let copilotSubagents;
+    const copilotWorkspace = mode === "copilot" ? (0, copilotHooks_1.readCopilotWorkspace)(transcript_path) : {};
     if (parserMode === "opencode") {
         transcriptContent = (0, utils_1.normalizeOpenCodeTranscript)(transcriptContent);
     }
     else if (parserMode === "cursor") {
         transcriptContent = (0, cursorHooks_1.normalizeCursorTranscript)(transcriptContent);
+        const observations = (0, cursorLifecycle_1.cursorLifecycleRecords)(session_id);
+        if (observations)
+            transcriptContent += `\n${observations}`;
+    }
+    else if (parserMode === "copilot") {
+        const normalized = (0, copilotHooks_1.normalizeCopilotTranscript)(transcriptContent, { clientName: copilotWorkspace.clientName });
+        transcriptContent = normalized.content;
+        copilotSubagents = normalized.subagents.count > 0 ? normalized.subagents : undefined;
+    }
+    else if (parserMode === "pi") {
+        transcriptContent = (0, piHooks_1.normalizePiTranscript)(transcriptContent);
+    }
+    if (mode === "cursor" || mode === "copilot" || mode === "pi") {
+        try {
+            await (0, limitEventReporter_1.reportTranscriptLimitEvent)({ config, source: mode, sessionId: session_id, transcript: transcriptContent });
+        }
+        catch { }
     }
-    // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
-    // need the git remote of the workspace.
     let remoteUrl = null;
     if (parserMode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
-    // The worktrees the session actually wrote to — resolved up front because
-    // they both anchor the branch/sha join keys below AND back-fill the repo tag
-    // when the launch dir is a multi-repo WORKSPACE root (a parent folder of
-    // several cloned repos) that has no remote of its own.
     const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
     if (!remoteUrl) {
         remoteUrl = (0, utils_1.resolveCaptureRemoteUrl)(workspaceRoot, captureDirs);
     }
-    // Capture-first: the transcript is the asset; the repo is just a tag. We do
-    // NOT bail when `remoteUrl` is null — that previously dropped EVERY session
-    // for users whose workspace couldn't resolve a remote (no git binary on lean
-    // Alpine images, no `origin`, or a submodule whose parent .git isn't mounted),
-    // with no error and a green `doctor`. Upload regardless; the backend accepts
-    // an unmatched capture (repoId null) and surfaces it for triage.
-    //
-    // Best-effort local match — backend re-resolves from `remoteUrl` against the
-    // company's current repo list, so a stale/empty local cache doesn't matter.
+    if (remoteUrl)
+        remoteUrl = (0, utils_1.stripRepoUrlCredentials)(remoteUrl);
     const matchedRepo = remoteUrl ? (0, utils_1.matchRepo)(remoteUrl, config.repos) : null;
     const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
         : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
-    // Cursor can emit duplicate lifecycle notifications while one transcript
-    // path is still byte-empty. Never use parsed message count here: Cursor's
-    // private JSONL shape can evolve independently, and parser drift must not
-    // silently discard a real non-empty session.
-    if (parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)) {
+    const emptyReason = parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)
+        ? "empty-cursor-transcript"
+        : parserMode === "copilot" && (0, copilotHooks_1.isCopilotTranscriptEmpty)(rawTranscriptContent)
+            ? "empty-copilot-transcript"
+            : parserMode === "pi" && (0, piHooks_1.isPiTranscriptEmpty)(rawTranscriptContent)
+                ? "empty-pi-transcript"
+                : null;
+    if (emptyReason) {
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
             sessionId: session_id,
             outcome: "skip",
-            detail: "empty-cursor-transcript",
+            detail: emptyReason,
         });
-        // A non-final stop snapshot is only a backup; reporting it as a skipped
-        // session would close/remove server-side start coverage while the session
-        // is still alive. The real SessionEnd remains responsible for a skip ping.
         if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
-            await postSessionSkip(config, session_id, "empty-cursor-transcript");
+            await postSessionSkip(config, session_id, emptyReason);
         }
         return;
     }
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
-    // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
-    // server-side against a merged MR/PR's source_branch / commits for AI attribution.
-    // Capture from the worktree the agent actually worked in (the launch dir stays
-    // on main/detached when work happens in a `git worktree`), not workspaceRoot.
-    // One session can touch several worktrees (→ several PRs); capture EVERY
-    // worktree's branch+sha so all the resulting PRs attribute. branch/headSha
-    // remain the primary (most-recent) values for back-compat.
     const keys = (0, utils_1.collectCaptureKeys)(captureDirs);
     const gitRefs = (0, utils_1.collectCaptureGitRefs)(captureDirs);
-    // Union the worktree-dir branches with the branches the agent actually
-    // committed/pushed to (parsed from the transcript's git output). Like the
-    // SHAs below, these are independent of end-of-session filesystem state, so
-    // they rescue branch-join when the worktree was REMOVED before SessionEnd
-    // (the dominant miss: dir-resolution falls back to the parent's branch, never
-    // the `worktree-<name>` one the PR was opened from). Indexed server-side under
-    // every branch in the array, so the worktree's PR attributes regardless.
     const authoredBranches = (0, utils_1.parseAuthoredBranches)(transcriptContent);
-    const branches = [...new Set([...keys.branches, ...authoredBranches])];
+    const recordedBranches = copilotWorkspace.branch ? [copilotWorkspace.branch] : [];
+    const branches = [...new Set([...keys.branches, ...authoredBranches, ...recordedBranches])];
     const branch = keys.branch ?? branches[0] ?? null;
-    // Union the worktree HEAD shas with the SHAs the agent actually committed/
-    // pushed (parsed from the transcript's git output, resolved via the shared
-    // object store). The authored shas are independent of end-of-session
-    // filesystem state, so they rescue attribution when a worktree is stale/gone.
     const authoredShas = (0, utils_1.parseAuthoredShas)(transcriptContent, workspaceRoot);
     const headShas = [...new Set([...keys.headShas, ...authoredShas])];
     const headSha = keys.headSha ?? headShas[0] ?? null;
     const pullRequestUrls = (0, utils_1.parsePullRequestUrls)(transcriptContent);
-    // Cost/velocity/steering signals parsed straight from the transcript we're
-    // already holding — no extra hooks, no extra git/process calls. parseUsage
-    // keeps the literal mode (it has its own desktop parser) and reads the RAW
-    // pre-normalization content for desktop; parseSteering routes through
-    // parserMode like the parsers above.
     const usage = (0, utils_1.parseUsage)(mode === "desktop" ? rawTranscriptContent : transcriptContent, mode);
+    const subagents = mode === "claude-code"
+        ? (0, subagents_1.readSubagentTranscripts)(transcript_path, session_id)
+        : { contents: [], count: 0, truncated: false };
+    const subagentUsage = (0, subagents_1.foldSubagentModelUsage)([], subagents, mode);
+    for (const u of subagentUsage) {
+        usage.inputTokens = (usage.inputTokens ?? 0) + u.inputTokens;
+        usage.outputTokens = (usage.outputTokens ?? 0) + u.outputTokens;
+        usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + u.cacheReadTokens;
+        usage.cacheCreationTokens = (usage.cacheCreationTokens ?? 0) + u.cacheCreationTokens;
+        usage.cacheTokens = (usage.cacheTokens ?? 0) + u.cacheReadTokens + u.cacheCreationTokens;
+    }
+    const hasUsage = mode === "cursor" ? (0, cursorHooks_1.cursorTranscriptHasUsage)(transcriptContent)
+        : mode === "copilot" ? (0, transcriptModels_1.parseTranscriptModels)(transcriptContent, mode).some(model => model.tokensAvailable !== false)
+            : true;
+    if (mode === "cursor" && !usage.model)
+        usage.model = (0, cursorHooks_1.cursorObservedModel)(transcriptContent) ?? null;
     const sessionStartedAt = (0, utils_1.parseSessionStart)(transcriptContent);
     const steering = (0, utils_1.parseSteering)(transcriptContent, parserMode);
     const payload = (0, utils_1.buildCapturePayload)({
@@ -964,31 +800,26 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         headShas,
         gitRefs,
         pullRequestUrls,
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens,
-        cacheTokens: usage.cacheTokens,
-        cacheReadTokens: usage.cacheReadTokens,
-        cacheCreationTokens: usage.cacheCreationTokens,
+        inputTokens: hasUsage ? usage.inputTokens : undefined,
+        outputTokens: hasUsage ? usage.outputTokens : undefined,
+        cacheTokens: hasUsage ? usage.cacheTokens : undefined,
+        cacheReadTokens: hasUsage ? usage.cacheReadTokens : undefined,
+        cacheCreationTokens: hasUsage ? usage.cacheCreationTokens : undefined,
         model: usage.model,
+        captureSignals: withCopilotSubagents((0, subagents_1.foldSubagentSignals)((0, captureSignals_1.withLaunch)((0, captureSignals_1.parseCaptureSignals)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode), input.launch), subagents, mode), copilotSubagents),
+        modelUsage: (0, subagents_1.foldSubagentModelUsage)((0, transcriptModels_1.parseTranscriptModels)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode), subagents, mode),
         sessionStartedAt,
         interruptCount: steering.interrupts,
         rejectionCount: steering.rejections,
-        // Carry the final flag into the HTTP body — the server uses it to decide
-        // whether to close the session lease (true) or renew it (false/absent).
         final: input.final,
-        // Desktop-only measured spend (undefined for every other source).
         costUsd: usage.costUsd,
     });
-    // Throttle decision: final captures go immediately; non-final (per-turn Stop)
-    // are deferred if we uploaded this session recently, to avoid per-turn churn.
     const uploadState = (0, utils_1.readSessionUploadState)(session_id ?? "");
     const decision = (0, utils_1.decideDispatch)({
         final: input.final === true,
         lastUploadAt: uploadState?.lastUploadAt ?? null,
         now: Date.now(),
     });
-    // Log capture-finish outcome with dispatch context so doctor can see whether
-    // the upload went immediately or was deferred (and by how much).
     (0, captureLog_1.appendCaptureLog)({
         stage: "capture-finish",
         sessionId: session_id,
@@ -997,11 +828,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             ? `dispatch=deferred delayMs=${decision.delayMs} final=${input.final === true} repo=${remoteUrl ?? "-"} branch=${branch ?? "-"} msgs=${stats.messageCount}`
             : `dispatch=immediate final=${input.final === true} repo=${remoteUrl ?? "-"} branch=${branch ?? "-"} msgs=${stats.messageCount}`,
     });
-    // Fire the upload from a further-detached child. We're already off the
-    // shutdown clock here, but reusing dispatchCaptureDetached keeps the upload
-    // retry + last-capture breadcrumb logic (runCaptureUpload) intact verbatim.
-    // Per-session job file: one file per session; newer turns overwrite it,
-    // which is the "supersede" mechanism for the deferred path.
     try {
         const hookScriptPath = process.argv[1];
         const tmpFile = (0, utils_1.captureUploadTmpFile)(session_id, decision.mode);
@@ -1012,21 +838,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 body: payload,
                 scopePaths,
             }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
-            // The immediate payload is durable before removing the older scheduled
-            // snapshot. Do this for every immediate dispatch, not only SessionEnd:
-            // first/outside-window snapshots also supersede a sleeping deferred job.
             if (session_id)
                 (0, utils_1.cancelDeferredCaptureUpload)(session_id);
-            // Retry any earlier capture jobs that failed to upload (transient network
-            // blips), excluding the one we just dispatched. Best-effort, detached.
-            // Skip the sweep on deferred path — the deferred child will handle uploading.
-            //
-            // Orphan pings are COLLECTED and awaited below: this child process calls
-            // process.exit(0) as soon as runCaptureFinish resolves, so a
-            // fire-and-forget POST here would be killed mid-flight — after the
-            // orphan file was already unlinked, i.e. the loss would stay invisible
-            // forever. The await is off the shutdown clock (detached child) and
-            // bounded by PING_TIMEOUT_MS.
             const orphanPings = [];
             (0, utils_1.sweepPendingCaptures)({
                 dir: os.tmpdir(),
@@ -1038,9 +851,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 exclude: tmpFile,
                 openSync: fs.openSync,
                 closeSync: fs.closeSync,
-                // Orphaned finish-inputs (capture-finish child died before writing an
-                // upload job): unrecoverable payload, but report the loss so it lands
-                // as a skip-reason instead of a silent coverage hole.
                 unlinkSync: fs.unlinkSync,
                 reportOrphan: (sid) => {
                     orphanPings.push(postSessionSkip(config, sid, "finish-orphaned"));
@@ -1049,9 +859,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             await Promise.all(orphanPings);
         }
         else {
-            // Deferred: write the job file (newer turns overwrite = supersede), then
-            // spawn the deferred-upload child which will sleep, claim, and upload.
-            // Same stdio/fd-hygiene contract as dispatchCaptureDetached.
             (0, utils_1.dispatchDeferredUpload)({
                 url: `${config.backendUrl}/api/captureSession`,
                 token: config.token,
@@ -1064,6 +871,10 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
     }
 }
+const COPILOT_SHUTDOWN_WAIT_MS = 5000;
+function withCopilotSubagents(signals, subagents) {
+    return subagents ? { ...signals, subagents } : signals;
+}
 main().catch(() => {
     process.exit(0);
 });