codiedev 0.9.59 → 0.9.61

package/dist/cursorLifecycle.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCursorLifecycle = recordCursorLifecycle;
+exports.cursorLifecycleRecords = cursorLifecycleRecords;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const configDir_1 = require("./configDir");
+const limitEvent_1 = require("./limitEvent");
+/** Retain aborted-turn evidence across non-final captures, which are snapshots. */
+function fileFor(sessionId) {
+    const key = crypto.createHash("sha256").update(sessionId).digest("hex");
+    return path.join((0, configDir_1.codiedevStateDir)(), "cursor-lifecycle", `${key}.json`);
+}
+function recordCursorLifecycle(input, final) {
+    if (typeof input.session_id !== "string")
+        return;
+    const status = input.status ?? input.reason;
+    const file = fileFor(input.session_id);
+    let state = { ids: [] };
+    try {
+        state = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch { /* first observation */ }
+    const model = typeof input.model_id === "string" && input.model_id.trim() ? input.model_id
+        : typeof input.model === "string" && input.model.trim() ? input.model : undefined;
+    if (model)
+        state.model = model;
+    const event = typeof input.hook_event_name === "string" ? input.hook_event_name : final ? "sessionEnd" : "stop";
+    // sessionEnd can arrive long after the agent stopped. Do not count that
+    // window-open time as active work. These are observed hook times, not
+    // invented per-message timestamps.
+    if (event !== "sessionEnd" || !state.observations?.length) {
+        const timestamp = new Date().toISOString();
+        state.observations = [...(state.observations ?? []), { event, timestamp, ...(model ? { model } : {}) }].slice(-1000);
+    }
+    const limit = event === "postToolUse" || event === "postToolUseFailure" ? null : (0, limitEvent_1.parseNativeLimitError)(input);
+    if (limit) {
+        const generationId = typeof input.generation_id === "string" ? input.generation_id : undefined;
+        const last = state.limits?.at(-1);
+        const retry = last && (generationId ? last.generationId === generationId
+            : final && state.lastStatus === "error" && last.reason === limit.reason && last.resetText === limit.resetText);
+        if (!retry)
+            state.limits = [...(state.limits ?? []), { ...limit, ...(generationId ? { generationId } : {}) }].slice(-1000);
+    }
+    if (event === "subagentStart" && typeof input.subagent_id === "string") {
+        state.subagents = [...new Set([...(state.subagents ?? []), input.subagent_id])].slice(-1000);
+    }
+    if (event === "postToolUseFailure" && input.failure_type === "permission_denied") {
+        const rejectionId = typeof input.tool_use_id === "string" ? input.tool_use_id : `${Date.now()}-${state.rejections?.length ?? 0}`;
+        state.rejections = [...new Set([...(state.rejections ?? []), rejectionId])].slice(-1000);
+    }
+    const aborted = status === "aborted" || input.is_interrupt === true;
+    // sessionEnd after an aborted stop is the same interruption. A repeated
+    // stop with the same generation_id is likewise a retry, not another turn.
+    const id = typeof input.generation_id === "string" ? input.generation_id
+        : `${Date.now()}-${state.ids.length}`;
+    if (aborted && !(final && state.lastStatus === "aborted") && !state.ids.includes(id))
+        state.ids.push(id);
+    if (typeof status === "string")
+        state.lastStatus = status;
+    state.ids = state.ids.slice(-1000);
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
+}
+function cursorLifecycleRecords(sessionId) {
+    if (!sessionId)
+        return "";
+    try {
+        const state = JSON.parse(fs.readFileSync(fileFor(sessionId), "utf8"));
+        return [...(state.observations ?? []).map((observation) => JSON.stringify({ type: "system", subtype: "cursor_hook_observation", ...observation })),
+            ...(state.model ? [JSON.stringify({ type: "system", subtype: "cursor_model", model: state.model })] : []),
+            ...(state.rejections ?? []).map(id => JSON.stringify({ type: "agent.rejection", id })),
+            ...(state.subagents?.length ? [JSON.stringify({ type: "cursor.subagent_summary", count: state.subagents.length, truncated: state.subagents.length >= 1000 })] : []),
+            ...state.ids.map((id) => JSON.stringify({ type: "agent.interruption", id })),
+            ...(state.limits ?? []).map(({ generationId: _generationId, ...event }) => JSON.stringify({ type: "agent.limit", ...event })),
+        ].join("\n");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/hook.js

@@ -44,11 +44,16 @@ 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 version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
+const subagents_1 = require("./subagents");
 const captureExclusions_1 = require("./captureExclusions");
 const cursorHooks_1 = require("./cursorHooks");
+const copilotHooks_1 = require("./copilotHooks");
 // 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
@@ -72,28 +77,31 @@ function buildDiscoveryContext(skills) {
 // 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) {
@@ -255,7 +263,7 @@ async function postSessionSkip(config, sessionId, reason) {
 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`, {
@@ -268,7 +276,7 @@ async function runSessionStart(hookInput, source = "claude-code") {
             /* 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)
@@ -415,6 +423,8 @@ 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-desktop" || arg === "capture-desktop-final")
@@ -524,7 +534,9 @@ 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 {
@@ -537,16 +549,39 @@ async function main() {
     if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
         process.exit(0);
     }
+    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 { /* best-effort local evidence */ }
+    }
+    if (process.argv[2] === "observe-cursor") {
+        process.stdout.write("{}");
+        return; // local evidence only
+    }
+    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 { /* best-effort */ }
+        }
+        return;
+    }
     // UserPromptSubmit discovery path — separate from session capture.
     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") {
         // A Codex block leaves no hook of its own, so this prompt is the first
         // chance to report it. Runs before runDiscover, which exits the process.
         if (process.argv[2] === "discover-codex") {
             await runCodexLimitSweep(hookInput.session_id);
         }
-        await runDiscover(hookInput.prompt);
+        if (process.argv[2] !== "discover-copilot")
+            await runDiscover(hookInput.prompt);
         return;
     }
     // StopFailure (matcher rate_limit): post the rate-limit event.
@@ -561,12 +596,23 @@ async function main() {
     // 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-copilot" ||
         process.argv[2] === "session-start-opencode") {
         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"
+                    : "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].filter(Boolean).join("\n\n"))));
+        }
         return;
     }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
@@ -577,12 +623,22 @@ async function main() {
     if ((process.argv[2] ?? "").endsWith("-cursor")) {
         (0, utils_1.ensureCursorCodiedevHooksInstalled)();
     }
+    else if ((process.argv[2] ?? "").endsWith("-copilot")) {
+        (0, utils_1.ensureCopilotCodiedevHooksInstalled)();
+    }
     else {
         (0, utils_1.ensureAllCodiedevHooksInstalled)();
     }
     if (process.argv[2] === "capture-codex")
         (0, utils_1.ensureCodexLimitHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
+    // Read here, in the process the harness spawned: the detached capture child
+    // is reparented once this exits and can no longer see who launched it.
+    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();
@@ -594,17 +650,20 @@ async function main() {
     // 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 (process.argv[2] === "backup" || process.argv[2] === "backup-cursor" || process.argv[2] === "backup-copilot") {
         if (transcript_path) {
             try {
                 (0, utils_1.dispatchCaptureFinish)({
-                    // "capture" = the claude-code entrypoint literal, same as the
-                    // SessionEnd path below (resolveMode maps it to claude-code).
-                    mode: process.argv[2] === "backup-cursor" ? "capture-cursor" : "capture",
+                    mode: process.argv[2] === "backup-cursor"
+                        ? "capture-cursor"
+                        : process.argv[2] === "backup-copilot"
+                            ? "capture-copilot"
+                            : "capture",
                     session_id,
                     transcript_path,
                     cwd,
                     workspace_roots,
+                    ...(launch ? { launch } : {}),
                     // non-final: server should renew the lease, not close it yet.
                     final: false,
                 }, process.argv[1], {
@@ -660,10 +719,10 @@ async function main() {
             transcript_path,
             cwd,
             workspace_roots,
-            // final:true ONLY for claude-code's SessionEnd. Codex routes its
-            // per-turn Stop hook through "capture-codex" — final:true there would
-            // close the server lease every turn. Cursor SessionEnd is final:true;
-            // Codex remains the legacy final-omitted per-turn path.
+            ...(launch ? { launch } : {}),
+            // final:true for real SessionEnd signals (Claude Code, Cursor, Copilot).
+            // Codex routes its per-turn Stop hook through "capture-codex" —
+            // final:true there would close the server lease every turn.
             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 });
     }
@@ -728,6 +787,15 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
+        // Copilot writes session.shutdown (the token totals) just AFTER sessionEnd
+        // fires. This child is detached, so wait briefly for it on the final
+        // capture. VS Code may never write one; then tokens stay unreported.
+        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
@@ -751,11 +819,27 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // 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;
+    }
+    if (mode === "cursor" || mode === "copilot") {
+        try {
+            await (0, limitEventReporter_1.reportTranscriptLimitEvent)({ config, source: mode, sessionId: session_id, transcript: transcriptContent });
+        }
+        catch { /* capture proceeds if limit reporting fails */ }
     }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
     // need the git remote of the workspace.
@@ -784,19 +868,26 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
         : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
-    // Never use parsed message count here: Cursor's private JSONL shape can
-    // evolve independently, and parser drift must not discard a real session.
-    if (parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)) {
+    // 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.
+    const emptyReason = parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)
+        ? "empty-cursor-transcript"
+        : parserMode === "copilot" && (0, copilotHooks_1.isCopilotTranscriptEmpty)(rawTranscriptContent)
+            ? "empty-copilot-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 server-side coverage while the session is alive.
         if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
-            await postSessionSkip(config, session_id, "empty-cursor-transcript");
+            await postSessionSkip(config, session_id, emptyReason);
         }
         return;
     }
@@ -818,7 +909,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // 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])];
+    // Copilot records the branch it started on in workspace.yaml.
+    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
@@ -834,6 +927,25 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // pre-normalization content for desktop; parseSteering routes through
     // parserMode like the parsers above.
     const usage = (0, utils_1.parseUsage)(mode === "desktop" ? rawTranscriptContent : transcriptContent, mode);
+    // Claude Code subagents: their transcripts sit beside this one and are part
+    // of this session's work (skill runs, tool calls, tokens). Folded in here,
+    // never uploaded as sessions of their own.
+    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)({
@@ -852,14 +964,14 @@ 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: (0, captureSignals_1.parseCaptureSignals)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode),
-        modelUsage: (0, transcriptModels_1.parseTranscriptModels)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode),
+        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,
@@ -953,6 +1065,12 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
     }
 }
+// How long the final Copilot capture waits for session.shutdown.
+const COPILOT_SHUTDOWN_WAIT_MS = 5000;
+/** Copilot fleet sub-agents run inside the one events.jsonl. */
+function withCopilotSubagents(signals, subagents) {
+    return subagents ? { ...signals, subagents } : signals;
+}
 main().catch(() => {
     process.exit(0);
 });

package/dist/launchContext.d.ts

@@ -0,0 +1,46 @@
+export declare function codieLaunchFromArgv(argv: readonly string[]): string;
+/** One launching process's command line → a Cursor launch value. */
+export declare function cursorLaunchFromCommand(command: string): string | undefined;
+/**
+ * One launching process's command line → a Copilot CLI launch value. The CLI
+ * runs as `…/@github/copilot-<platform>/copilot [flags]` under
+ * `node …/bin/copilot [flags]`; `-p`/`--prompt` is headless (scripted). VS
+ * Code's agent (`copilot-runtime --headless`) is named by workspace.yaml
+ * instead, so it never matches here.
+ */
+export declare function copilotLaunchFromCommand(command: string): string | undefined;
+type Ps = (pid: number) => {
+    ppid: number;
+    command: string;
+} | null;
+/**
+ * Windows: one PowerShell call returns the whole ancestor chain (spawning
+ * PowerShell per level would cost ~0.5s each). CommandLine needs CIM, which
+ * every supported Windows has; any failure means "unknown", never a guess.
+ */
+export declare function windowsAncestors(startPid: number, depth: number): Array<{
+    pid: number;
+    ppid: number;
+    command: string;
+}> | null;
+type LaunchDeps = {
+    platform?: string;
+    ps?: Ps;
+    depth?: number;
+    windows?: typeof windowsAncestors;
+};
+/**
+ * Walk up to `depth` ancestors (a shell or `npx` usually sits between Cursor
+ * and the hook) and return the first Cursor launch found.
+ */
+export declare function detectCursorLaunch(startPid?: number, deps?: LaunchDeps): string | undefined;
+/** The Copilot CLI that launched this hook (`copilot:print` / `copilot:cli`). */
+export declare function detectCopilotLaunch(startPid?: number, deps?: LaunchDeps): string | undefined;
+/** The launch value a hook invocation should carry into its capture job. */
+export declare function hookLaunch(hookCommand: string | undefined, input: {
+    launch?: unknown;
+}, deps?: {
+    copilotClientName?: string;
+    detectCopilot?: () => string | undefined;
+}): string | undefined;
+export {};