codiedev 0.9.58 → 0.9.60

package/assets/tui-brand-plugin.tsx

@@ -31,6 +31,7 @@ const MARK = [
 const REFRESH_MS = 30_000
 
 const [usageLine, setUsageLine] = createSignal("")
+const [usageTone, setUsageTone] = createSignal("normal")
 
 async function startUsagePolling() {
   let usage: any
@@ -56,7 +57,11 @@ async function startUsagePolling() {
       })
       // A failed poll leaves the last good line up rather than blanking it:
       // a number that stopped updating beats a number that vanished.
-      if (snapshot) setUsageLine(usage.formatUsageLine(snapshot))
+      if (snapshot) {
+        setUsageLine(usage.formatUsageLine(snapshot))
+        // Older installs of the usage module have no tone; stay muted there.
+        if (typeof usage.usageTone === "function") setUsageTone(usage.usageTone(snapshot))
+      }
     } catch {}
   }
   void poll()
@@ -69,7 +74,14 @@ void startUsagePolling().catch(() => {})
 
 function StatusLine(props: { theme: any }) {
   return (
-    <text fg={props.theme.textMuted} selectable={false}>
+    <text
+      fg={usageTone() === "critical"
+        ? (props.theme.error ?? props.theme.textMuted)
+        : usageTone() === "warn"
+          ? (props.theme.warning ?? props.theme.textMuted)
+          : props.theme.textMuted}
+      selectable={false}
+    >
       {usageLine()}
     </text>
   )

package/dist/captureSignals.d.ts

@@ -8,12 +8,29 @@ export type CaptureSignals = {
     activeMs: number;
     idleThresholdMs: number;
     skillInvocations: string[];
+    /** How many times each invoked skill ran (each Skill tool call and each
+     *  slash command): three review runs in one session count three. Absent
+     *  from older CLIs, which only sent the unique set above. */
+    skillInvocationCounts?: Array<{
+        skill: string;
+        count: number;
+    }>;
     skillPulls: string[];
     toolCalls: Array<{
         name: string;
         calls: number;
     }>;
+    /** How the harness was launched, raw: Claude Code's "cli" / "sdk-cli",
+     * Codex's "codex:cli" / "codex:exec". Absent when the harness records none. */
+    entrypoints?: string[];
+    /** Claude Code subagent transcripts folded into these signals. */
+    subagents?: {
+        count: number;
+        truncated: boolean;
+    };
     truncated: boolean;
 };
 /** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
 export declare function parseCaptureSignals(content: string, source?: string): CaptureSignals;
+/** Add a launch value the hook detected (harnesses that do not record one). */
+export declare function withLaunch(signals: CaptureSignals, launch: string | undefined): CaptureSignals;

package/dist/captureSignals.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPTURE_SIGNALS_VERSION = void 0;
 exports.parseCaptureSignals = parseCaptureSignals;
+exports.withLaunch = withLaunch;
 const transcriptModels_1 = require("./transcriptModels");
 exports.CAPTURE_SIGNALS_VERSION = 1;
 const IDLE_MS = 5 * 60_000;
@@ -17,7 +18,8 @@ const skillKey = (value) => typeof value === "string"
 /** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
 function parseCaptureSignals(content, source) {
     const timestamps = new Set();
-    const invocations = new Set(), pulls = new Set();
+    const invocationCounts = new Map();
+    const invocations = new Set(), pulls = new Set(), entrypoints = new Set();
     const tools = new Map(), calls = new Set();
     let parsedRecords = 0, truncated = false;
     const addSkill = (set, value) => {
@@ -29,6 +31,8 @@ function parseCaptureSignals(content, source) {
             return;
         }
         set.add(key);
+        if (set === invocations)
+            invocationCounts.set(key, (invocationCounts.get(key) ?? 0) + 1);
     };
     const command = (value) => {
         if (typeof value !== "string")
@@ -66,6 +70,24 @@ function parseCaptureSignals(content, source) {
             continue;
         const e = record;
         parsedRecords++;
+        const entrypoint = (value) => {
+            if (typeof value === "string" &&
+                entrypoints.size < 10 &&
+                /^[a-z0-9][a-z0-9_.:-]{0,39}$/i.test(value))
+                entrypoints.add(value.toLowerCase());
+        };
+        // Claude Code: "cli" at the terminal, "sdk-cli" for `claude -p` / SDK.
+        entrypoint(e.entrypoint);
+        // Codex: session_meta.source is "cli", "vscode", "exec" (`codex exec`),
+        // "mcp", or an object for sub-agents. Namespaced so values never collide.
+        if (e.type === "session_meta" && e.payload) {
+            const src = e.payload.source;
+            entrypoint(typeof src === "string"
+                ? `codex:${src}`
+                : src && typeof src === "object"
+                    ? `codex:${Object.keys(src)[0] ?? "other"}`
+                    : undefined);
+        }
         const time = typeof e.timestamp === "string"
             ? Date.parse(e.timestamp)
             : e.info?.time?.created;
@@ -110,10 +132,21 @@ function parseCaptureSignals(content, source) {
         activeMs,
         idleThresholdMs: IDLE_MS,
         skillInvocations: [...invocations].sort(),
+        skillInvocationCounts: [...invocationCounts]
+            .map(([skill, count]) => ({ skill, count }))
+            .sort((a, b) => a.skill.localeCompare(b.skill)),
         skillPulls: [...pulls].sort(),
         toolCalls: [...tools]
             .map(([name, calls]) => ({ name, calls }))
             .sort((a, b) => a.name.localeCompare(b.name)),
+        ...(entrypoints.size ? { entrypoints: [...entrypoints].sort() } : {}),
         truncated,
     };
 }
+/** Add a launch value the hook detected (harnesses that do not record one). */
+function withLaunch(signals, launch) {
+    if (!launch || !/^[a-z0-9][a-z0-9_.:-]{0,39}$/.test(launch))
+        return signals;
+    const all = new Set([...(signals.entrypoints ?? []), launch]);
+    return all.size > 10 ? signals : { ...signals, entrypoints: [...all].sort() };
+}

package/dist/codieUsage.d.ts

@@ -39,6 +39,13 @@ export interface CodieUsage {
  * Returns "" when there is nothing honest to say.
  */
 export declare function formatUsageLine(usage: CodieUsage | null | undefined): string;
+export type UsageTone = "normal" | "warn" | "critical";
+/**
+ * How urgently the status line should read, from the limit that will stop
+ * this developer first: their own cap, or the shared pool when they have no
+ * cap or the pool runs out sooner. 75% warns, 90% is critical.
+ */
+export declare function usageTone(usage: CodieUsage | null | undefined): UsageTone;
 /**
  * What this session just cost. Returns "" when the session billed nothing,
  * because a developer who spent nothing does not need to be told a number.

package/dist/codieUsage.js

@@ -9,6 +9,7 @@
 // delay, or break a coding session. No snapshot means no line.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatUsageLine = formatUsageLine;
+exports.usageTone = usageTone;
 exports.formatSessionCostLine = formatSessionCostLine;
 exports.fetchCodieUsage = fetchCodieUsage;
 const USAGE_TIMEOUT_MS = 4000;
@@ -51,6 +52,16 @@ function formatUsageLine(usage) {
         const share = percent(budget.userSpentUsd, budget.userBudgetUsd);
         if (share)
             segments.push(share);
+        // A personal cap does not help once the shared pool is nearly gone: say
+        // so when the pool is running low and will stop this developer before
+        // their own cap does.
+        if (poolBindsFirst(budget) && typeof budget.companyBudgetUsd === "number"
+            && budget.companyBudgetUsd > 0
+            && budget.companySpentUsd / budget.companyBudgetUsd >= 0.75) {
+            const share = percent(budget.companySpentUsd, budget.companyBudgetUsd);
+            if (share)
+                segments.push(`team pool ${share}`);
+        }
     }
     else {
         segments.push(money(budget.userSpentUsd));
@@ -62,6 +73,10 @@ function formatUsageLine(usage) {
                 segments.push(`team ${share}`);
         }
     }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && budget.companySpentUsd >= budget.companyBudgetUsd) {
+        segments.push("team pool used up");
+    }
     if (inFlight.requests > 0)
         segments.push(`${inFlight.requests} in flight`);
     // Stale holds cap a budget while doing no work. Naming them is the
@@ -70,6 +85,37 @@ function formatUsageLine(usage) {
         segments.push(`${money(inFlight.staleHeldUsd)} held stale`);
     return segments.join(" · ");
 }
+function poolBindsFirst(budget) {
+    if (typeof budget.companyBudgetUsd !== "number" || typeof budget.userBudgetUsd !== "number")
+        return false;
+    const poolLeft = Math.max(0, budget.companyBudgetUsd - budget.companySpentUsd);
+    const userLeft = Math.max(0, budget.userBudgetUsd - budget.userSpentUsd);
+    return budget.userBudgetUsd > 0 && poolLeft < userLeft;
+}
+/**
+ * How urgently the status line should read, from the limit that will stop
+ * this developer first: their own cap, or the shared pool when they have no
+ * cap or the pool runs out sooner. 75% warns, 90% is critical.
+ */
+function usageTone(usage) {
+    if (!usage || !usage.enabled)
+        return "normal";
+    const { budget } = usage;
+    const ratios = [];
+    if (typeof budget.userBudgetUsd === "number" && budget.userBudgetUsd > 0) {
+        ratios.push(budget.userSpentUsd / budget.userBudgetUsd);
+    }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && (typeof budget.userBudgetUsd !== "number" || poolBindsFirst(budget))) {
+        ratios.push(budget.companySpentUsd / budget.companyBudgetUsd);
+    }
+    const worst = ratios.length ? Math.max(...ratios) : 0;
+    if (worst >= 0.9)
+        return "critical";
+    if (worst >= 0.75)
+        return "warn";
+    return "normal";
+}
 function tokens(total) {
     // Rounded by arithmetic, not toFixed: 2.55 is not exactly representable, so
     // toFixed(1) rounds it down and the same count can read two ways.

package/dist/hook.js

@@ -45,8 +45,10 @@ const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
 const limitEventReporter_1 = require("./limitEventReporter");
 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");
 // Pure builder for the discovery additionalContext. Returns null when there are
@@ -583,6 +585,9 @@ async function main() {
     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);
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
@@ -605,6 +610,7 @@ async function main() {
                     transcript_path,
                     cwd,
                     workspace_roots,
+                    ...(launch ? { launch } : {}),
                     // non-final: server should renew the lease, not close it yet.
                     final: false,
                 }, process.argv[1], {
@@ -660,6 +666,7 @@ async function main() {
             transcript_path,
             cwd,
             workspace_roots,
+            ...(launch ? { launch } : {}),
             // 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;
@@ -834,6 +841,20 @@ 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 sessionStartedAt = (0, utils_1.parseSessionStart)(transcriptContent);
     const steering = (0, utils_1.parseSteering)(transcriptContent, parserMode);
     const payload = (0, utils_1.buildCapturePayload)({
@@ -858,8 +879,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         cacheReadTokens: usage.cacheReadTokens,
         cacheCreationTokens: usage.cacheCreationTokens,
         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: (0, subagents_1.foldSubagentSignals)((0, captureSignals_1.withLaunch)((0, captureSignals_1.parseCaptureSignals)(mode === "desktop" || mode === "opencode" ? rawTranscriptContent : transcriptContent, mode), input.launch), subagents, mode),
+        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,

package/dist/launchContext.d.ts

@@ -0,0 +1,32 @@
+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;
+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;
+/**
+ * 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?: {
+    platform?: string;
+    ps?: Ps;
+    depth?: number;
+    windows?: typeof windowsAncestors;
+}): string | undefined;
+/** The launch value a hook invocation should carry into its capture job. */
+export declare function hookLaunch(hookCommand: string | undefined, input: {
+    launch?: unknown;
+}): string | undefined;
+export {};

package/dist/launchContext.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codieLaunchFromArgv = codieLaunchFromArgv;
+exports.cursorLaunchFromCommand = cursorLaunchFromCommand;
+exports.windowsAncestors = windowsAncestors;
+exports.detectCursorLaunch = detectCursorLaunch;
+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 and Codie 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;
+}
+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;
+    }
+}
+/**
+ * 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 = {}) {
+    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 = cursorLaunchFromCommand(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 = cursorLaunchFromCommand(row.command);
+        if (launch)
+            return launch;
+        pid = row.ppid;
+    }
+    return undefined;
+}
+/** The launch value a hook invocation should carry into its capture job. */
+function hookLaunch(hookCommand, input) {
+    if (typeof input.launch === "string" && VALUE.test(input.launch))
+        return input.launch;
+    if (hookCommand?.endsWith("-cursor"))
+        return detectCursorLaunch();
+    return undefined;
+}

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/utils.d.ts

@@ -231,6 +231,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;

package/dist/utils.js

@@ -1072,6 +1072,9 @@ function installOpenCodeCapturePlugin() {
         `const CAPTURE = ${JSON.stringify(capture)};\n` +
         `const FINISH = ${JSON.stringify(finish)};\n` +
         `const PROMPT = ${JSON.stringify(prompt)};\n` +
+        `// How this Codie process was started (run / serve / tui). OpenCode records\n` +
+        `// nothing about it, so the plugin reads its own argv; see launchContext.ts.\n` +
+        `const LAUNCH = (() => { const sub = process.argv.slice(2).find((a) => ["run", "serve", "acp", "web", "attach"].includes(a)); return sub ? "codie:" + sub : "codie:tui"; })();\n` +
         `const fingerprints = new Map();\n\n` +
         `const transcriptPaths = new Map();\n\n` +
         `function sessionId(event) {\n` +
@@ -1098,7 +1101,7 @@ function installOpenCodeCapturePlugin() {
         `  const finalizeAll = () => {\n` +
         `    for (const [id, transcriptPath] of transcriptPaths) {\n` +
         `      const cwd = worktree || directory || process.cwd();\n` +
-        `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `    }\n` +
         `  };\n` +
         `  process.once("exit", finalizeAll);\n` +
@@ -1116,12 +1119,12 @@ function installOpenCodeCapturePlugin() {
         `    if (!id) return;\n` +
         `    const cwd = worktree || directory || process.cwd();\n` +
         `    if (event.type === "session.created") {\n` +
-        `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
+        `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `      return;\n` +
         `    }\n` +
         `    if (event.type === "session.deleted") {\n` +
         `      const transcriptPath = transcriptPaths.get(id);\n` +
-        `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `      transcriptPaths.delete(id);\n` +
         `      fingerprints.delete(id);\n` +
         `      return;\n` +
@@ -1141,7 +1144,7 @@ function installOpenCodeCapturePlugin() {
         `      const transcriptPath = path.join(captureDir, safeId + ".json");\n` +
         `      await writeFile(transcriptPath, JSON.stringify(list), { mode: 0o600 });\n` +
         `      transcriptPaths.set(id, transcriptPath);\n` +
-        `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `    } catch {}\n` +
         `  },\n` +
         `  });\n` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.58",
+  "version": "0.9.60",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",