codiedev 0.9.59 → 0.9.61

package/dist/launchContext.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codieLaunchFromArgv = codieLaunchFromArgv;
+exports.cursorLaunchFromCommand = cursorLaunchFromCommand;
+exports.copilotLaunchFromCommand = copilotLaunchFromCommand;
+exports.windowsAncestors = windowsAncestors;
+exports.detectCursorLaunch = detectCursorLaunch;
+exports.detectCopilotLaunch = detectCopilotLaunch;
+exports.hookLaunch = hookLaunch;
+const node_child_process_1 = require("node:child_process");
+/**
+ * How a harness that records nothing about its own launch was started.
+ * Claude Code (`entrypoint`) and Codex (`session_meta.source`) stamp this in
+ * the transcript; Cursor, Codie and the Copilot CLI do not, so the hook reads
+ * it from the process that launched it. Raw, namespaced values; what counts as
+ * "automated" is decided in reporting, not here.
+ */
+const VALUE = /^[a-z0-9][a-z0-9_.:-]{0,39}$/;
+/** Codie (OpenCode) subcommands, read in-process by the capture plugin. */
+const CODIE_SUBCOMMANDS = ["run", "serve", "acp", "web", "attach"];
+function codieLaunchFromArgv(argv) {
+    const sub = argv.find((a) => CODIE_SUBCOMMANDS.includes(a));
+    return sub ? `codie:${sub}` : "codie:tui";
+}
+/**
+ * Split a command line into tokens, honouring double quotes (Windows quotes
+ * paths with spaces: "C:\\Program Files\\…\\node.exe" "…\\index.js" -p hi).
+ */
+function tokenize(command) {
+    const tokens = [];
+    for (const m of command.matchAll(/"([^"]*)"|(\S+)/g))
+        tokens.push(m[1] ?? m[2]);
+    return tokens;
+}
+/** A path segment named cursor-agent / agent (Unix or Windows separators). */
+const CURSOR_AGENT_PATH = /(^|[/\\])cursor-agent([/\\]|\.(exe|cmd|ps1)$|$)/i;
+const AGENT_BIN = /(^|[/\\])(cursor-)?agent(\.(exe|cmd|ps1))?$/i;
+/** One launching process's command line → a Cursor launch value. */
+function cursorLaunchFromCommand(command) {
+    const tokens = tokenize(command);
+    // The CLI runs as `<launcher> [node] …/cursor-agent/versions/<v>/index.js [flags] [prompt]`
+    // on macOS/Linux (~/.local/share/cursor-agent) and Windows (%LOCALAPPDATA%\cursor-agent).
+    const isAgent = tokens.some((t) => CURSOR_AGENT_PATH.test(t) || /[/\\]\.local[/\\]share[/\\]cursor/i.test(t))
+        && tokens.some((t) => AGENT_BIN.test(t) || /index\.js$/i.test(t));
+    if (isAgent) {
+        return cursorFlags(tokens).some((f) => f === "-p" || f === "--print" || f.startsWith("--print="))
+            ? "cursor:print"
+            : "cursor:cli";
+    }
+    if (/Cursor\.app|Cursor Helper|[/\\]cursor(\.exe)?(\s|"|$)/i.test(command))
+        return "cursor:ide";
+    return undefined;
+}
+/** Cursor flags that take a value; the token after them is not the prompt. */
+const CURSOR_VALUE_FLAGS = new Set(["--model", "-m", "--output-format", "--api-key", "--resume", "--workspace", "--mode", "-H", "--header"]);
+/**
+ * The flags before the prompt. The prompt is on the command line too, so a
+ * prompt mentioning "-p" must not read as headless: stop at the first token
+ * that is neither a flag nor a flag's value. Starts after the launcher script
+ * (`…/index.js`) when present, else after the agent binary.
+ */
+function cursorFlags(tokens) {
+    let start = tokens.findIndex((t) => /index\.js$/i.test(t));
+    if (start < 0)
+        start = tokens.findIndex((t) => AGENT_BIN.test(t));
+    const flags = [];
+    for (let i = (start >= 0 ? start : 0) + 1; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (!t.startsWith("-"))
+            break;
+        flags.push(t);
+        if (CURSOR_VALUE_FLAGS.has(t))
+            i++;
+    }
+    return flags;
+}
+/** The Copilot CLI binary or its npm launcher (`copilot`, `copilot.exe`, `copilot.cmd`). */
+const COPILOT_BIN = /(^|[/\\])copilot(\.(exe|cmd|ps1|js))?$/i;
+const NODE_BIN = /(^|[/\\])node(\.exe)?$/i;
+/**
+ * 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.
+ */
+function copilotLaunchFromCommand(command) {
+    const tokens = tokenize(command);
+    // Only the program itself (or the script `node` runs): a shell command line
+    // that merely mentions "copilot" as a word is not the Copilot CLI.
+    const bin = COPILOT_BIN.test(tokens[0] ?? "")
+        ? 0
+        : NODE_BIN.test(tokens[0] ?? "") && COPILOT_BIN.test(tokens[1] ?? "")
+            ? 1
+            : -1;
+    if (bin < 0)
+        return undefined;
+    for (let i = bin + 1; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "-p" || t === "--prompt" || t.startsWith("--prompt="))
+            return "copilot:print";
+        // The prompt itself can mention "-p": stop at the first non-flag token.
+        if (!t.startsWith("-"))
+            break;
+        if (COPILOT_VALUE_FLAGS.has(t))
+            i++;
+    }
+    return "copilot:cli";
+}
+/** Copilot CLI flags that take a value; the token after them is not a flag. */
+const COPILOT_VALUE_FLAGS = new Set([
+    "--model", "--add-dir", "--allow-tool", "--deny-tool", "--resume", "--log-dir",
+    "--log-level", "--agent", "--config-dir", "--allow-url", "--deny-url",
+    "--additional-mcp-config", "--stream", "--output-format",
+]);
+const psPosix = (pid) => {
+    const result = (0, node_child_process_1.spawnSync)("ps", ["-o", "ppid=,args=", "-p", String(pid)], { encoding: "utf8", timeout: 500 });
+    const line = result.status === 0 ? result.stdout.trim() : "";
+    const match = line.match(/^(\d+)\s+(.*)$/s);
+    return match ? { ppid: Number(match[1]), command: match[2] } : 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.
+ */
+function windowsAncestors(startPid, depth) {
+    const script = `$p=${Math.trunc(startPid)};$o=@();for($i=0;$i -lt ${Math.trunc(depth)} -and $p -gt 0;$i++){` +
+        `$x=Get-CimInstance Win32_Process -Filter "ProcessId=$p" -ErrorAction SilentlyContinue;if(!$x){break};` +
+        `$o+=[pscustomobject]@{pid=[int]$p;ppid=[int]$x.ParentProcessId;command=[string]$x.CommandLine};$p=$x.ParentProcessId};` +
+        `ConvertTo-Json -InputObject @($o) -Compress`;
+    const result = (0, node_child_process_1.spawnSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+        encoding: "utf8",
+        // A cold PowerShell start can take several seconds on a busy machine; the
+        // capture hook has 30s, and an unanswered walk just means "unknown".
+        timeout: 10000,
+        windowsHide: true,
+    });
+    if (result.status !== 0 || !result.stdout.trim())
+        return null;
+    try {
+        const rows = JSON.parse(result.stdout);
+        return rows.map((r) => ({ pid: Number(r.pid), ppid: Number(r.ppid), command: r.command ?? "" }));
+    }
+    catch {
+        return null;
+    }
+}
+/** First launch value `fromCommand` finds among up to `depth` ancestors. */
+function detectLaunch(fromCommand, startPid, deps) {
+    const depth = deps.depth ?? 5;
+    if ((deps.platform ?? process.platform) === "win32" && !deps.ps) {
+        const chain = (deps.windows ?? windowsAncestors)(startPid, depth);
+        if (!chain)
+            return undefined;
+        for (const row of chain) {
+            const launch = fromCommand(row.command);
+            if (launch)
+                return launch;
+        }
+        return undefined;
+    }
+    const ps = deps.ps ?? psPosix;
+    let pid = startPid;
+    for (let i = 0; i < depth && pid > 1; i++) {
+        const row = ps(pid);
+        if (!row)
+            return undefined;
+        const launch = fromCommand(row.command);
+        if (launch)
+            return launch;
+        pid = row.ppid;
+    }
+    return undefined;
+}
+/**
+ * Walk up to `depth` ancestors (a shell or `npx` usually sits between Cursor
+ * and the hook) and return the first Cursor launch found.
+ */
+function detectCursorLaunch(startPid = process.ppid, deps = {}) {
+    return detectLaunch(cursorLaunchFromCommand, startPid, deps);
+}
+/** The Copilot CLI that launched this hook (`copilot:print` / `copilot:cli`). */
+function detectCopilotLaunch(startPid = process.ppid, deps = {}) {
+    return detectLaunch(copilotLaunchFromCommand, startPid, deps);
+}
+/** The launch value a hook invocation should carry into its capture job. */
+function hookLaunch(hookCommand, input, deps = {}) {
+    if (typeof input.launch === "string" && VALUE.test(input.launch))
+        return input.launch;
+    if (hookCommand?.endsWith("-cursor"))
+        return detectCursorLaunch();
+    if (hookCommand?.endsWith("-copilot")) {
+        // VS Code names itself in workspace.yaml; only the CLI needs the walk.
+        if (deps.copilotClientName === "vscode-agent-host")
+            return "copilot:vscode";
+        return (deps.detectCopilot ?? detectCopilotLaunch)();
+    }
+    return undefined;
+}

package/dist/limitEvent.d.ts

@@ -9,4 +9,7 @@ export declare function classifyLimitKind(text: string): LimitKind;
 export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;
 /** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
 export declare function parseCodexLimitEventFromTranscript(transcript: string): LimitEvent | null;
+/** Only explicit provider errors qualify; never scan user/assistant prose. */
+export declare function parseNativeLimitError(input: Record<string, unknown>, now?: number): LimitEvent | null;
+export declare function parseNativeLimitEventFromTranscript(transcript: string): LimitEvent | null;
 export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;

package/dist/limitEvent.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLimitKind = classifyLimitKind;
 exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
 exports.parseCodexLimitEventFromTranscript = parseCodexLimitEventFromTranscript;
+exports.parseNativeLimitError = parseNativeLimitError;
+exports.parseNativeLimitEventFromTranscript = parseNativeLimitEventFromTranscript;
 exports.tailForLimitEvent = tailForLimitEvent;
 function classifyLimitKind(text) {
     const t = text.toLowerCase();
@@ -129,6 +131,46 @@ function parseCodexLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+/** Only explicit provider errors qualify; never scan user/assistant prose. */
+function parseNativeLimitError(input, now = Date.now()) {
+    const context = input.errorContext ?? input.error_context;
+    if (context !== undefined && context !== "model_call")
+        return null;
+    const error = input.error;
+    const fields = error && typeof error === "object" ? error : {};
+    const code = String(fields.code ?? fields.name ?? input.error_code ?? "");
+    const text = typeof error === "string" ? error
+        : typeof fields.message === "string" ? fields.message
+            : typeof input.error_message === "string" ? input.error_message : "";
+    if (!/^(?:429|rate[_-]?limit(?:ed|_exceeded|_error)?|RateLimitError|quota_exceeded)$/i.test(code)
+        && !/\b(?:rate limit (?:exceeded|reached)|too many requests|usage limit (?:exceeded|reached)|premium requests? (?:exhausted|limit reached))\b/i.test(text))
+        return null;
+    const rawAt = input.timestamp;
+    const parsedAt = typeof rawAt === "number" ? rawAt : typeof rawAt === "string" ? Date.parse(rawAt) : NaN;
+    return { kind: classifyLimitKind(text), at: Number.isFinite(parsedAt) && parsedAt > 0 ? parsedAt : now,
+        resetText: parseResetText(text), reason: code || "rate_limit" };
+}
+function parseNativeLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === "agent.limit" && Number.isFinite(entry.at) && entry.at > 0
+                && ["session", "user_spend", "org_spend", "other"].includes(entry.kind)) {
+                found = { kind: entry.kind, at: entry.at, resetText: typeof entry.resetText === "string" ? entry.resetText : null,
+                    ...(typeof entry.reason === "string" ? { reason: entry.reason } : {}) };
+                continue;
+            }
+            if (!entry.timestamp)
+                continue; // no stable timestamp means snapshots cannot deduplicate
+            if (entry.type === "agent.error" || entry.type === "session.error") {
+                found = parseNativeLimitError({ ...(entry.data ?? entry), timestamp: entry.timestamp }) ?? found;
+            }
+        }
+        catch { /* tolerant of incomplete transcript tails */ }
+    }
+    return found;
+}
 // Tail of the raw transcript to ship with the limit event so the server can
 // summarize "what they were working on" immediately — without waiting for the
 // SessionEnd capture (which can lag hours, or drop entirely on Windows).

package/dist/limitEventReporter.d.ts

@@ -1,5 +1,5 @@
 import { type LimitEvent } from "./limitEvent";
-export type LimitEventSource = "claude-code" | "codex";
+export type LimitEventSource = "claude-code" | "codex" | "cursor" | "copilot";
 export type LimitEventPayload = LimitEvent & {
     source: LimitEventSource;
     sessionId?: string;

package/dist/limitEventReporter.js

@@ -76,7 +76,7 @@ function postLimitEvent(config, payload, timeoutMs = 5_000) {
 async function reportTranscriptLimitEvent(args) {
     const parse = args.source === "codex"
         ? limitEvent_1.parseCodexLimitEventFromTranscript
-        : limitEvent_1.parseLimitEventFromTranscript;
+        : args.source === "cursor" || args.source === "copilot" ? limitEvent_1.parseNativeLimitEventFromTranscript : limitEvent_1.parseLimitEventFromTranscript;
     const parsed = parse(args.transcript);
     if (!parsed && !args.emitMinimalOnMiss)
         return false;

package/dist/nativeSteering.d.ts

@@ -0,0 +1,5 @@
+/** Native records only: quoted denial/interrupt text in conversation is not evidence. */
+export declare function parseNativeSteering(content: string): {
+    interrupts: number;
+    rejections: number;
+};

package/dist/nativeSteering.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNativeSteering = parseNativeSteering;
+/** Native records only: quoted denial/interrupt text in conversation is not evidence. */
+function parseNativeSteering(content) {
+    const interrupts = new Set();
+    const abortedTurns = new Set();
+    const rejections = new Set();
+    for (const [index, line] of content.split("\n").entries()) {
+        try {
+            const event = JSON.parse(line);
+            const id = String(event.id ?? event.uuid ?? event.toolCallId ?? index);
+            if (event.type === "agent.interruption")
+                interrupts.add(id);
+            if (event.type === "turn_ended" && event.status === "aborted")
+                abortedTurns.add(id);
+            if (event.type === "agent.rejection")
+                rejections.add(id);
+            // Cursor tool failures distinguish a user-denied permission from an
+            // ordinary tool failure. Don't guess from free-form error messages.
+            if (event.type === "tool_result" && event.error?.code === "user_denied")
+                rejections.add(id);
+        }
+        catch { /* incomplete transcript records are ignored */ }
+    }
+    return { interrupts: Math.max(interrupts.size, abortedTurns.size), rejections: rejections.size };
+}

package/dist/subagents.d.ts

@@ -0,0 +1,36 @@
+import { type CaptureSignals } from "./captureSignals";
+import { type TranscriptModelUsage } from "./transcriptModels";
+/**
+ * Claude Code writes each subagent's transcript next to its parent's:
+ *
+ *   ~/.claude/projects/<project>/<sessionId>.jsonl                 (parent)
+ *   ~/.claude/projects/<project>/<sessionId>/subagents/agent-*.jsonl
+ *
+ * Lines there carry `isSidechain: true` and the parent's sessionId. They are
+ * part of the parent session's work, not sessions of their own: their skill
+ * runs, tool calls and token usage fold into the parent's signals and usage,
+ * and they are never uploaded separately. Other harnesses (Codex, Codie,
+ * Cursor) keep sub-agents inside the one transcript or don't have them, so
+ * this is Claude Code only.
+ */
+export declare const SUBAGENT_LIMITS: {
+    files: number;
+    bytes: number;
+};
+export declare function subagentDir(transcriptPath: string, sessionId?: string): string;
+export type SubagentTranscripts = {
+    contents: string[];
+    count: number;
+    truncated: boolean;
+};
+/** Read the session's subagent transcripts in full, up to 20 files / 20 MB
+ *  in total (oldest first); anything past that is counted as truncated. */
+export declare function readSubagentTranscripts(transcriptPath: string, sessionId?: string, limits?: {
+    files: number;
+    bytes: number;
+}): SubagentTranscripts;
+/** Parent signals plus every subagent's skill runs, pulls and tool calls.
+ *  Launch values, timing and record counts stay the parent's own. */
+export declare function foldSubagentSignals(parent: CaptureSignals, subs: SubagentTranscripts, source?: string): CaptureSignals;
+/** Parent model usage plus each subagent's, summed per model. */
+export declare function foldSubagentModelUsage(parent: TranscriptModelUsage[], subs: SubagentTranscripts, source?: string): TranscriptModelUsage[];

package/dist/subagents.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBAGENT_LIMITS = void 0;
+exports.subagentDir = subagentDir;
+exports.readSubagentTranscripts = readSubagentTranscripts;
+exports.foldSubagentSignals = foldSubagentSignals;
+exports.foldSubagentModelUsage = foldSubagentModelUsage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const captureSignals_1 = require("./captureSignals");
+const transcriptModels_1 = require("./transcriptModels");
+/**
+ * Claude Code writes each subagent's transcript next to its parent's:
+ *
+ *   ~/.claude/projects/<project>/<sessionId>.jsonl                 (parent)
+ *   ~/.claude/projects/<project>/<sessionId>/subagents/agent-*.jsonl
+ *
+ * Lines there carry `isSidechain: true` and the parent's sessionId. They are
+ * part of the parent session's work, not sessions of their own: their skill
+ * runs, tool calls and token usage fold into the parent's signals and usage,
+ * and they are never uploaded separately. Other harnesses (Codex, Codie,
+ * Cursor) keep sub-agents inside the one transcript or don't have them, so
+ * this is Claude Code only.
+ */
+exports.SUBAGENT_LIMITS = { files: 20, bytes: 20 * 1024 * 1024 };
+function subagentDir(transcriptPath, sessionId) {
+    const dir = node_path_1.default.dirname(transcriptPath);
+    const id = sessionId || node_path_1.default.basename(transcriptPath).replace(/\.jsonl$/i, "");
+    return node_path_1.default.join(dir, id, "subagents");
+}
+/** Read the session's subagent transcripts in full, up to 20 files / 20 MB
+ *  in total (oldest first); anything past that is counted as truncated. */
+function readSubagentTranscripts(transcriptPath, sessionId, limits = exports.SUBAGENT_LIMITS) {
+    const dir = subagentDir(transcriptPath, sessionId);
+    let names;
+    try {
+        names = node_fs_1.default.readdirSync(dir).filter((n) => /^agent-[^/]+\.jsonl$/.test(n));
+    }
+    catch {
+        return { contents: [], count: 0, truncated: false };
+    }
+    const files = names
+        .map((n) => {
+        const full = node_path_1.default.join(dir, n);
+        try {
+            const st = node_fs_1.default.statSync(full);
+            return st.isFile() ? { full, size: st.size, mtime: st.mtimeMs } : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((f) => f !== null)
+        .sort((a, b) => a.mtime - b.mtime || a.full.localeCompare(b.full));
+    const contents = [];
+    let bytes = 0;
+    let truncated = false;
+    for (const f of files) {
+        if (contents.length >= limits.files || bytes + f.size > limits.bytes) {
+            truncated = true;
+            break;
+        }
+        try {
+            contents.push(node_fs_1.default.readFileSync(f.full, "utf8"));
+            bytes += f.size;
+        }
+        catch {
+            truncated = true;
+        }
+    }
+    return { contents, count: files.length, truncated };
+}
+/** Parent signals plus every subagent's skill runs, pulls and tool calls.
+ *  Launch values, timing and record counts stay the parent's own. */
+function foldSubagentSignals(parent, subs, source) {
+    if (subs.count === 0)
+        return parent;
+    const counts = new Map();
+    const add = (list, fallback) => {
+        for (const c of list ?? fallback.map((skill) => ({ skill, count: 1 })))
+            counts.set(c.skill, (counts.get(c.skill) ?? 0) + c.count);
+    };
+    add(parent.skillInvocationCounts, parent.skillInvocations);
+    const invocations = new Set(parent.skillInvocations);
+    const pulls = new Set(parent.skillPulls);
+    const tools = new Map(parent.toolCalls.map((t) => [t.name, t.calls]));
+    let truncated = parent.truncated;
+    for (const content of subs.contents) {
+        const s = (0, captureSignals_1.parseCaptureSignals)(content, source);
+        add(s.skillInvocationCounts, s.skillInvocations);
+        for (const k of s.skillInvocations)
+            invocations.add(k);
+        for (const k of s.skillPulls)
+            pulls.add(k);
+        for (const t of s.toolCalls)
+            tools.set(t.name, (tools.get(t.name) ?? 0) + t.calls);
+        truncated ||= s.truncated;
+    }
+    const cap = (xs) => {
+        if (xs.length > 100)
+            truncated = true;
+        return xs.slice(0, 100);
+    };
+    return {
+        ...parent,
+        skillInvocations: cap([...invocations].sort()),
+        skillInvocationCounts: cap([...counts].map(([skill, count]) => ({ skill, count: Math.min(count, 10_000) })).sort((a, b) => a.skill.localeCompare(b.skill))),
+        skillPulls: cap([...pulls].sort()),
+        toolCalls: cap([...tools].map(([name, calls]) => ({ name, calls })).sort((a, b) => a.name.localeCompare(b.name))),
+        subagents: { count: subs.count, truncated: subs.truncated },
+        truncated,
+    };
+}
+/** Parent model usage plus each subagent's, summed per model. */
+function foldSubagentModelUsage(parent, subs, source) {
+    if (subs.contents.length === 0)
+        return parent;
+    const byModel = new Map();
+    const add = (u) => {
+        const cur = byModel.get(u.model);
+        if (!cur) {
+            byModel.set(u.model, { ...u });
+            return;
+        }
+        cur.requests += u.requests;
+        cur.inputTokens += u.inputTokens;
+        cur.outputTokens += u.outputTokens;
+        cur.cacheReadTokens += u.cacheReadTokens;
+        cur.cacheCreationTokens += u.cacheCreationTokens;
+        if (u.costUsd !== undefined)
+            cur.costUsd = (cur.costUsd ?? 0) + u.costUsd;
+        if (u.reportedCostUsd !== undefined)
+            cur.reportedCostUsd = (cur.reportedCostUsd ?? 0) + u.reportedCostUsd;
+        if (u.reasoningTokens !== undefined)
+            cur.reasoningTokens = (cur.reasoningTokens ?? 0) + u.reasoningTokens;
+    };
+    for (const u of parent)
+        add(u);
+    for (const content of subs.contents)
+        for (const u of (0, transcriptModels_1.parseTranscriptModels)(content, source))
+            add(u);
+    return [...byModel.values()].slice(0, 64);
+}

package/dist/teamSkillContext.d.ts

@@ -0,0 +1,9 @@
+/** Session-start context uses each client's supported output contract. */
+export declare const TEAM_SKILL_CONTEXT = "This machine is connected to Codiedev, the team's artifact and skill library.\nBefore a substantial coding task, run codiedev search \"<brief task description>\" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.\nUse codiedev push <file.md> to share an artifact when asked, codiedev ask \"<question>\" for team knowledge, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.";
+export declare function teamSkillSessionOutput(source: "cursor" | "copilot", context?: string): {
+    additional_context: string;
+    additionalContext?: undefined;
+} | {
+    additionalContext: string;
+    additional_context?: undefined;
+};

package/dist/teamSkillContext.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEAM_SKILL_CONTEXT = void 0;
+exports.teamSkillSessionOutput = teamSkillSessionOutput;
+/** Session-start context uses each client's supported output contract. */
+exports.TEAM_SKILL_CONTEXT = `This machine is connected to Codiedev, the team's artifact and skill library.
+Before a substantial coding task, run codiedev search "<brief task description>" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.
+Use codiedev push <file.md> to share an artifact when asked, codiedev ask "<question>" for team knowledge, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.`;
+function teamSkillSessionOutput(source, context = exports.TEAM_SKILL_CONTEXT) {
+    return source === "cursor" ? { additional_context: context } : { additionalContext: context };
+}

package/dist/transcriptModels.d.ts

@@ -1,6 +1,8 @@
 /** Compact per-model usage, derived from captured transcript records. */
 export type TranscriptModelUsage = {
     model: string;
+    /** False for Copilot model/request hints before token totals arrive. */
+    tokensAvailable?: boolean;
     /** Assistant message IDs; nonzero cumulative usage events for Codex. */
     requests: number;
     inputTokens: number;

package/dist/transcriptModels.js

@@ -44,6 +44,7 @@ function* transcriptRecords(content, source) {
 function parseTranscriptModels(content, source) {
     const buckets = new Map();
     const messages = new Map();
+    const tokenEvidence = new Set();
     let model = "Unattributed";
     let previous = {
         inputTokens: 0,
@@ -143,9 +144,12 @@ function parseTranscriptModels(content, source) {
             model =
                 typeof message.model === "string" ? message.model : "Unattributed";
             const raw = message.usage;
+            // Copilot's shutdown token totals carry `requests: 0`: its calls are
+            // already counted from the assistant records.
+            const requests = event.requests;
             usage = {
                 ...empty(model),
-                requests: 1,
+                requests: typeof requests === "number" && Number.isFinite(requests) ? Math.max(0, requests) : 1,
                 inputTokens: positive(raw.input_tokens),
                 outputTokens: positive(raw.output_tokens),
                 cacheReadTokens: positive(raw.cache_read_input_tokens),
@@ -153,6 +157,8 @@ function parseTranscriptModels(content, source) {
             };
             messageId = message.id ?? event.uuid ?? messageId;
         }
+        if (source === "copilot" && event.type === "copilot.usage")
+            tokenEvidence.add(usage.model);
         // Client placeholders are not model executions.
         if (!usage.model.trim() || usage.model.startsWith("<"))
             continue;
@@ -197,7 +203,7 @@ function parseTranscriptModels(content, source) {
         delete buckets.get(key).costUsd;
     for (const key of incompleteReasoning)
         delete buckets.get(key).reasoningTokens;
-    return [...buckets.values()];
+    return [...buckets.values()].map(row => source === "copilot" && !tokenEvidence.has(row.model) ? { ...row, tokensAvailable: false } : row);
 }
 function totalModelTokens(row) {
     return (row.inputTokens +

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import type { CaptureSignals } from "./captureSignals";
-import type { TranscriptModelUsage } from "./transcriptModels";
+import { type TranscriptModelUsage } from "./transcriptModels";
 import { spawn as nodeSpawn } from "child_process";
 import type { CaptureLogEntry } from "./captureLog";
 import { codiedevStateDir } from "./configDir";
@@ -89,6 +89,7 @@ export interface CapturePayloadInput {
     final?: boolean;
     costUsd?: number;
 }
+export declare function stripRepoUrlCredentials(url: string): string;
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
 export declare function extractHookNodePath(cmd: string | undefined): string | undefined;
@@ -96,6 +97,12 @@ export declare function resetStableNodeCacheForTests(): void;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
 export declare function cursorInstalled(): boolean;
+/**
+ * GitHub Copilot: `$COPILOT_HOME` / ~/.copilot (either surface has run once),
+ * the `copilot` CLI on PATH, or VS Code's Copilot Chat extension. VS Code's
+ * agent and the CLI read the same user hooks, so one install covers both.
+ */
+export declare function copilotInstalled(): boolean;
 export declare function openCodeInstalled(): boolean;
 /** Install a dormant global OpenCode adapter. Installing it unconditionally
  * keeps `codiedev connect` as the only setup step even when Codie/OpenCode is
@@ -116,6 +123,8 @@ export declare function ensureAllCodiedevHooksInstalled(): void;
 export declare function ensureSessionStartHookInstalled(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
+export declare function copilotInstructionsPath(): string;
+export declare function installCopilotInstructions(): void;
 export declare function installCursorInstructions(): void;
 /**
  * Install the Codiedev MCP server into Claude Code's user-scope config.
@@ -173,6 +182,13 @@ export declare function installCodexMcp(): boolean;
 export declare function installCodexHook(): void;
 export declare function ensureCodexLimitHookInstalled(): void;
 export declare function installCursorHook(): void;
+export declare function copilotHooksPath(): string;
+export declare function installCopilotHook(agentSecurityEnabled?: boolean): void;
+/** Self-heal the Copilot hook file after upgrades or drift (like Cursor's). */
+export declare function ensureCopilotCodiedevHooksInstalled(): void;
+/** Repair Cursor's complete flat hook set after upgrades or configuration
+ * drift. This is deliberately separate from Claude Code's nested-hook healer:
+ * the schemas and event names differ, and mixing them risks corrupting both. */
 export declare function ensureCursorCodiedevHooksInstalled(): void;
 export interface ParsedStats {
     messageCount: number;
@@ -184,7 +200,7 @@ export interface SteeringStats {
 }
 export declare function parseClaudeSteering(content: string): SteeringStats;
 export declare function parseCodexSteering(content: string): SteeringStats;
-export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode"): SteeringStats;
+export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode" | "copilot"): SteeringStats;
 export interface UsageStats {
     inputTokens: number;
     outputTokens: number;
@@ -196,7 +212,7 @@ export interface UsageStats {
     /** Engine-reported spend (opencode SDK `info.cost`). Desktop mode only. */
     costUsd?: number;
 }
-export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode" | "desktop"): UsageStats;
+export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode" | "desktop" | "copilot"): UsageStats;
 export declare function parseSessionStart(content: string): number | null;
 export declare function parseClaudeCodeStats(content: string): ParsedStats;
 /** Convert OpenCode's SDK message array (`{info, parts}[]`) into the same
@@ -231,6 +247,9 @@ export interface CaptureFinishInput {
     cwd?: string;
     workspace_roots?: string[];
     final?: boolean;
+    /** How the harness was launched when its transcript does not record it
+     *  (Cursor, Codie). See launchContext.ts. */
+    launch?: string;
 }
 export declare function dispatchCaptureFinish(input: CaptureFinishInput, hookScriptPath: string, deps: DispatchDeps): void;
 export declare function dispatchCaptureDetached(job: CaptureUploadJob, hookScriptPath: string, deps: DispatchDeps): void;