codiedev 0.9.13 → 0.9.15

package/dist/hook.js

@@ -41,6 +41,7 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
+const limitEvent_1 = require("./limitEvent");
 const version_1 = require("./version");
 function getJson(url, bearerToken) {
     return new Promise((resolve, reject) => {
@@ -103,6 +104,39 @@ async function runDiscover(prompt) {
     }
     process.exit(0);
 }
+// StopFailure (matcher rate_limit): the dev just got blocked. Read the local
+// transcript tail for the ground-truth rate_limit line and POST a tiny event.
+// Best-effort + silent — StopFailure output is ignored by Claude Code anyway.
+async function runStopFailure(hookInput) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        process.exit(0);
+    let event = null;
+    const tp = hookInput.transcript_path;
+    if (tp) {
+        try {
+            event = (0, limitEvent_1.parseLimitEventFromTranscript)(fs.readFileSync(tp, "utf8"));
+        }
+        catch {
+            /* unreadable transcript — fall through to minimal event */
+        }
+    }
+    // The hook is registered with matcher "rate_limit", so a miss still means a
+    // real limit — emit a minimal event rather than dropping it.
+    const payload = event ?? { kind: "other", at: Date.now(), resetText: null };
+    try {
+        await postJson(`${config.backendUrl}/api/cli/limitEvent`, {
+            kind: payload.kind,
+            at: payload.at,
+            resetText: payload.resetText,
+            sessionId: hookInput.session_id,
+        }, config.token);
+    }
+    catch {
+        /* best-effort */
+    }
+    process.exit(0);
+}
 function postJson(url, body, bearerToken) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -186,6 +220,34 @@ async function main() {
         await runBackupUpload(process.argv[3]);
         process.exit(0);
     }
+    // Detached capture-finish child (spawned by the SessionEnd capture path
+    // below). The job carries only the raw hook inputs; this child does ALL the
+    // heavy work — read the transcript, parse it, resolve git branch/SHAs (the
+    // per-SHA `git rev-parse` calls that were overrunning CC's shutdown window
+    // on Windows), build the payload, and dispatch the upload. Running here means
+    // none of it is on the SessionEnd shutdown clock, so it can never be
+    // "Hook cancelled". No stdin needed — handle it before readStdin().
+    if (process.argv[2] === "capture-finish") {
+        const jobFile = process.argv[3];
+        if (jobFile) {
+            try {
+                const job = JSON.parse(fs.readFileSync(jobFile, "utf8"));
+                await runCaptureFinish(job);
+            }
+            catch {
+                // best-effort — never throw out of the detached child
+            }
+            finally {
+                try {
+                    fs.unlinkSync(jobFile);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        process.exit(0);
+    }
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -201,12 +263,18 @@ async function main() {
         await runDiscover(hookInput.prompt);
         return;
     }
-    const mode = resolveMode(process.argv[2]);
+    // StopFailure (matcher rate_limit): post the rate-limit event.
+    if (process.argv[2] === "limit") {
+        await runStopFailure(hookInput);
+        return;
+    }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets the
-    // discovery + auto-backup hooks wired on their next SessionEnd, without
-    // re-connecting.
+    // discovery + auto-backup + limit hooks wired on their next SessionEnd, without
+    // re-connecting. Cheap (settings.json read, writes only when missing), so it
+    // stays inline; the costly transcript/git work is what moves to the child.
     (0, utils_1.ensureDiscoveryHookInstalled)();
     (0, utils_1.ensureBackupHookInstalled)();
+    (0, utils_1.ensureLimitHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
@@ -219,6 +287,15 @@ async function main() {
         runBackup(workspaceRoot, process.argv[1]);
         process.exit(0);
     }
+    // Capture path (SessionEnd). Do the ABSOLUTE MINIMUM inline so this hook
+    // exits 0 within Claude Code's SessionEnd shutdown window: a cheap config /
+    // transcript guard, then hand ALL the heavy work (transcript read + parse +
+    // per-SHA `git rev-parse` + upload) to a detached `capture-finish` child.
+    // Detaching only the upload (the old #240 fix) left the synchronous parse and
+    // git work on the shutdown clock, which still overran on Windows — where each
+    // subprocess spawn costs ~50-150ms — producing "Hook cancelled" even though
+    // the data still landed. JS can't be interrupted mid-sync-chain, so the work
+    // finished and the upload went through, but CC had already given up waiting.
     const config = (0, utils_1.readConfig)();
     if (!config) {
         process.exit(0);
@@ -226,12 +303,45 @@ async function main() {
     if (!transcript_path) {
         process.exit(0);
     }
+    try {
+        const jobFile = path.join(os.tmpdir(), `codiedev-capture-job-${session_id ?? process.pid}.json`);
+        (0, utils_1.dispatchCaptureFinish)({
+            mode: process.argv[2] ?? "capture",
+            session_id,
+            transcript_path,
+            cwd,
+            workspace_roots,
+        }, process.argv[1], { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile: jobFile });
+    }
+    catch (err) {
+        process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
+    }
+    process.exit(0);
+}
+// Runs inside the detached `capture-finish` child spawned by the SessionEnd
+// hook above. This is everything that used to run inline in main(): read the
+// transcript, resolve the repo, parse stats/usage/steering, resolve the git
+// branch + authored SHAs (the per-SHA `git rev-parse` calls that overran the
+// shutdown window on Windows), build the payload, and fire the upload from a
+// further-detached uploader. Running here means none of it is on the SessionEnd
+// shutdown clock, so it can never be "Hook cancelled". Best-effort throughout.
+async function runCaptureFinish(input) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        return;
+    const { session_id, transcript_path, cwd, workspace_roots } = input;
+    if (!transcript_path)
+        return;
+    const mode = resolveMode(input.mode);
+    const workspaceRoot = workspace_roots && workspace_roots.length > 0
+        ? workspace_roots[0]
+        : cwd || process.cwd();
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
     }
     catch {
-        process.exit(0);
+        return;
     }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
     // need the git remote of the workspace.
@@ -267,7 +377,16 @@ async function main() {
     // remain the primary (most-recent) values for back-compat.
     const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
     const keys = (0, utils_1.collectCaptureKeys)(captureDirs);
-    const { branch, branches } = keys;
+    // Union the worktree-dir branches with the branches the agent actually
+    // committed/pushed to (parsed from the transcript's git output). Like the
+    // SHAs below, these are independent of end-of-session filesystem state, so
+    // they rescue branch-join when the worktree was REMOVED before SessionEnd
+    // (the dominant miss: dir-resolution falls back to the parent's branch, never
+    // the `worktree-<name>` one the PR was opened from). Indexed server-side under
+    // every branch in the array, so the worktree's PR attributes regardless.
+    const authoredBranches = (0, utils_1.parseAuthoredBranches)(transcriptContent);
+    const branches = [...new Set([...keys.branches, ...authoredBranches])];
+    const branch = keys.branch ?? branches[0] ?? null;
     // Union the worktree HEAD shas with the SHAs the agent actually committed/
     // pushed (parsed from the transcript's git output, resolved via the shared
     // object store). The authored shas are independent of end-of-session
@@ -302,11 +421,9 @@ async function main() {
         interruptCount: steering.interrupts,
         rejectionCount: steering.rejections,
     });
-    // Fire the upload from a fully detached child and exit immediately. Awaiting
-    // it inline let Claude Code's SessionEnd shutdown window elapse and kill the
-    // still-running hook ("Hook cancelled") on large transcripts — even though
-    // the body had already reached the server. The detached child outlives this
-    // process and finishes the POST in the background.
+    // Fire the upload from a further-detached child. We're already off the
+    // shutdown clock here, but reusing dispatchCaptureDetached keeps the upload
+    // retry + last-capture breadcrumb logic (runCaptureUpload) intact verbatim.
     try {
         const hookScriptPath = process.argv[1];
         const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
@@ -324,7 +441,6 @@ async function main() {
     catch (err) {
         process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
     }
-    process.exit(0);
 }
 main().catch(() => {
     process.exit(0);

package/dist/limitEvent.d.ts

@@ -0,0 +1,8 @@
+export type LimitKind = "session" | "org_spend" | "other";
+export interface LimitEvent {
+    kind: LimitKind;
+    at: number;
+    resetText: string | null;
+}
+export declare function classifyLimitKind(text: string): LimitKind;
+export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;

package/dist/limitEvent.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyLimitKind = classifyLimitKind;
+exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
+function classifyLimitKind(text) {
+    const t = text.toLowerCase();
+    if (t.includes("session limit"))
+        return "session";
+    if (t.includes("spend limit") || t.includes("monthly spend"))
+        return "org_spend";
+    return "other";
+}
+// "… · resets 9:50pm (UTC)" → "9:50pm (UTC)". Null when absent.
+function parseResetText(text) {
+    const m = text.match(/resets\s+(.+?)\s*$/i);
+    return m ? m[1].trim() : null;
+}
+function messageText(entry) {
+    const c = entry?.message?.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        return c.map((x) => (x && typeof x === "object" ? x.text ?? "" : "")).join(" ");
+    return "";
+}
+// Scans transcript JSONL for the LAST top-level `error: "rate_limit"` entry.
+// (Validated shape: error/isApiErrorMessage are top-level, not under message.)
+function parseLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        if (!line.includes('"rate_limit"'))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (e?.error !== "rate_limit" && !e?.isApiErrorMessage)
+            continue;
+        const text = messageText(e);
+        const at = e?.timestamp ? Date.parse(e.timestamp) : NaN;
+        found = {
+            kind: classifyLimitKind(text),
+            at: Number.isNaN(at) ? Date.now() : at,
+            resetText: parseResetText(text),
+        };
+    }
+    return found;
+}

package/dist/repoResolver.js

@@ -25,17 +25,25 @@ function parseRemoteUrl(url) {
 }
 function resolveRepoForCapture(input) {
     const { remoteUrl, providedRepoId, companyRepos } = input;
-    if (providedRepoId) {
-        const hit = companyRepos.find((r) => r._id === providedRepoId);
-        if (hit)
-            return { repoId: hit._id, source: "provided" };
-    }
+    // The remoteUrl is the ground truth of where the work happened — resolve it
+    // FIRST. A buggy client can send a wrong-but-valid providedRepoId (the Sonifi
+    // case: client matchRepo stamped every session with the org's first repo), so
+    // we must not blindly trust it over the URL. Keep providedRepoId only when it
+    // AGREES with the URL match, or when the URL can't be resolved at all.
     const parsed = remoteUrl ? parseRemoteUrl(remoteUrl) : null;
-    if (!parsed) {
-        return { repoId: null, source: "unmatched" };
+    const urlMatch = parsed
+        ? companyRepos.find((r) => `${r.owner}/${r.name}`.toLowerCase() === parsed.ownerName)
+        : undefined;
+    const provided = providedRepoId
+        ? companyRepos.find((r) => r._id === providedRepoId)
+        : undefined;
+    if (urlMatch) {
+        if (provided && provided._id === urlMatch._id) {
+            return { repoId: provided._id, source: "provided" };
+        }
+        return { repoId: urlMatch._id, source: "resolved" };
     }
-    const match = companyRepos.find((r) => `${r.owner}/${r.name}`.toLowerCase() === parsed.ownerName);
-    if (match)
-        return { repoId: match._id, source: "resolved" };
+    if (provided)
+        return { repoId: provided._id, source: "provided" };
     return { repoId: null, source: "unmatched" };
 }

package/dist/utils.d.ts

@@ -36,7 +36,8 @@ export declare function collectCaptureKeys(dirs: string[], getBranch?: (d: strin
     headShas: string[];
 };
 export declare function extractShaTokens(transcriptContent: string): string[];
-export declare function parseAuthoredShas(transcriptContent: string, repoRoot: string, resolveFull?: (sha: string) => string | null): string[];
+export declare function parseAuthoredBranches(transcriptContent: string): string[];
+export declare function parseAuthoredShas(transcriptContent: string, repoRoot: string, resolveFullBatch?: (shas: string[]) => Map<string, string>): string[];
 export declare function getGitBranch(cwd: string): string | null;
 export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {
@@ -72,10 +73,11 @@ export declare function cursorInstalled(): boolean;
  * the presence of any `github.copilot*` directory as the Copilot fingerprint.
  */
 export declare function vscodeCopilotInstalled(): boolean;
-export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string): void;
+export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string, matcher?: string): void;
 export declare function installHook(): void;
 export declare function ensureDiscoveryHookInstalled(): void;
 export declare function ensureBackupHookInstalled(): void;
+export declare function ensureLimitHookInstalled(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
 export declare function installCursorInstructions(): void;
@@ -171,6 +173,14 @@ interface DispatchDeps {
     tmpFile: string;
     nodePath?: string;
 }
+export interface CaptureFinishInput {
+    mode: string;
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    workspace_roots?: string[];
+}
+export declare function dispatchCaptureFinish(input: CaptureFinishInput, hookScriptPath: string, deps: DispatchDeps): void;
 export declare function dispatchCaptureDetached(job: CaptureUploadJob, hookScriptPath: string, deps: DispatchDeps): void;
 interface SweepDeps {
     dir: string;

package/dist/utils.js

@@ -45,6 +45,7 @@ exports.resolveCaptureDir = resolveCaptureDir;
 exports.resolveCaptureDirs = resolveCaptureDirs;
 exports.collectCaptureKeys = collectCaptureKeys;
 exports.extractShaTokens = extractShaTokens;
+exports.parseAuthoredBranches = parseAuthoredBranches;
 exports.parseAuthoredShas = parseAuthoredShas;
 exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
@@ -58,6 +59,7 @@ exports.upsertCodiedevHook = upsertCodiedevHook;
 exports.installHook = installHook;
 exports.ensureDiscoveryHookInstalled = ensureDiscoveryHookInstalled;
 exports.ensureBackupHookInstalled = ensureBackupHookInstalled;
+exports.ensureLimitHookInstalled = ensureLimitHookInstalled;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
 exports.installCursorInstructions = installCursorInstructions;
@@ -79,6 +81,7 @@ exports.parseSessionStart = parseSessionStart;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
+exports.dispatchCaptureFinish = dispatchCaptureFinish;
 exports.dispatchCaptureDetached = dispatchCaptureDetached;
 exports.sweepPendingCaptures = sweepPendingCaptures;
 exports.buildLastCaptureRecord = buildLastCaptureRecord;
@@ -256,9 +259,13 @@ function matchRepo(remoteUrl, repos) {
     for (const repo of repos) {
         const normalizedUrl = normalizeRepoUrl(repo.url);
         const normalizedName = repo.fullName.toLowerCase();
+        // Match the REMOTE against this repo: exact normalized URL, or the remote
+        // ending with this repo's full path (`owner/.../name`). Both are anchored to
+        // `normalizedRemote` — never compare a repo to ITSELF (the old third clause
+        // `normalizedUrl.endsWith('/'+name)` was remote-independent and returned the
+        // first repo for every session, collapsing all repos for multi-repo orgs).
         if (normalizedRemote === normalizedUrl ||
-            normalizedRemote.endsWith(`/${normalizedName}`) ||
-            normalizedUrl.endsWith(`/${normalizedName}`)) {
+            normalizedRemote.endsWith(`/${normalizedName}`)) {
             return repo;
         }
     }
@@ -417,35 +424,124 @@ function extractShaTokens(transcriptContent) {
         out.add(m[1].toLowerCase());
     return [...out];
 }
+// Pull the branch NAMES the agent actually committed/pushed to, straight out of
+// the transcript's git OUTPUT — the branch companion to extractShaTokens. This
+// is the rescue for the dominant capture miss: the agent works in a
+// `.claude/worktrees/<name>` worktree on branch `worktree-<name>`, commits/pushes
+// /PRs, then the worktree is REMOVED before SessionEnd. resolveCaptureDirs then
+// can't resolve the (deleted) worktree's git dir and falls back to the parent
+// dir, capturing the PARENT's branch — so the PR's sourceBranch matches no
+// captured session. The branch name survives in the commit line `[branch sha]`
+// and the push ref `<local> -> <remote>`, both of which prove authorship (a
+// read-only `git log` emits neither), so this stays mutation-scoped like the
+// SHA parse. Pure string parse — no filesystem, no server change.
+function parseAuthoredBranches(transcriptContent) {
+    const out = [];
+    const add = (b) => {
+        if (b && !out.includes(b))
+            out.push(b);
+    };
+    const scan = (text, re) => {
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(text)))
+            add(m[1]);
+    };
+    // From git OUTPUT (proof the work shipped on that branch):
+    //   commit: `[<branch> [(root-commit) ]<sha>]`. `[^\]\s]+` rejects "detached
+    //     HEAD" (the space breaks the token before the sha can match).
+    //   push:   `<sha>..<sha>  <local> -> <remote>` (updated) / `[new branch]
+    //     <local> -> <remote>` (created). Anchor on the push-ref shape so prose
+    //     arrows ("a -> b") don't match; capture the remote (= the PR
+    //     sourceBranch). `[^\s"]+` stops at the JSON string boundary.
+    const commitRe = /\[([^\]\s]+)(?:\s+\(root-commit\))?\s+[0-9a-f]{7,40}\]/g;
+    const pushRe = /(?:[0-9a-f]{7,40}\.\.[0-9a-f]{7,40}|\[new branch\])\s+\S+\s+->\s+([^\s"]+)/g;
+    // From CREATE commands (rescues work committed/pushed entirely OUTSIDE the
+    // session): only `checkout -b`/`switch -c` (branch CREATION — not plain
+    // checkout/switch navigation), and only from real Bash tool_use inputs, never
+    // prose/output, so a suggested command in assistant text can't false-match.
+    const createRe = /\bgit\s+(?:checkout\s+-b|switch\s+-c)\s+([^\s"'&;|]+)/g;
+    for (const line of transcriptContent.split("\n")) {
+        if (!line.trim())
+            continue;
+        // commit/push output: scan the raw serialized line (output lives in string
+        // fields); robust to non-JSON / partial lines.
+        scan(line, commitRe);
+        scan(line, pushRe);
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const content = entry?.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const b of content) {
+            if (b?.type === "tool_use" && b.name === "Bash" && typeof b.input?.command === "string") {
+                scan(b.input.command, createRe);
+            }
+        }
+    }
+    return out;
+}
 // Resolve the extracted tokens to FULL 40-char SHAs via the repo's shared object
 // store (a worktree's commits live in the main repo's .git/objects, so they
 // resolve even after the worktree dir is removed). Full SHAs pass through; short
 // ones are resolved; unresolvable ones are dropped (a short sha can't exact-
 // match the worker's full commitShas). Keeps the server-side match exact.
-function parseAuthoredShas(transcriptContent, repoRoot, resolveFull = (sha) => defaultResolveFullSha(sha, repoRoot)) {
+function parseAuthoredShas(transcriptContent, repoRoot, resolveFullBatch = (shas) => defaultResolveFullShaBatch(shas, repoRoot)) {
     const out = new Set();
+    const shorts = new Set();
     for (const tok of extractShaTokens(transcriptContent)) {
-        if (tok.length === 40) {
+        if (tok.length === 40)
             out.add(tok);
-            continue;
+        else
+            shorts.add(tok);
+    }
+    if (shorts.size > 0) {
+        const resolved = resolveFullBatch([...shorts]);
+        for (const full of resolved.values()) {
+            if (full && /^[0-9a-f]{40}$/.test(full))
+                out.add(full.toLowerCase());
         }
-        const full = resolveFull(tok);
-        if (full && /^[0-9a-f]{40}$/.test(full))
-            out.add(full.toLowerCase());
     }
     return [...out];
 }
-function defaultResolveFullSha(sha, repoRoot) {
+// Resolve many short SHAs to full in ONE git spawn via `git cat-file
+// --batch-check` (reads requests on stdin, emits one result line per request,
+// in order). The previous one-`git rev-parse`-per-sha approach cost N spawns;
+// on Windows (~50-150ms/spawn) a long session's transcript made the detached
+// capture child run for tens of seconds (measured 28s for 40 shas on a real
+// windows-latest runner) — fragile if the child is torn down before it
+// finishes. This is ~constant-time regardless of sha count. Missing objects
+// yield a "<req> missing" line and are skipped. Never throws.
+function defaultResolveFullShaBatch(shas, repoRoot) {
+    const out = new Map();
+    if (shas.length === 0)
+        return out;
     try {
-        const r = (0, child_process_1.execSync)(`git rev-parse ${sha}^{commit}`, {
+        const input = shas.map((s) => `${s}^{commit}`).join("\n") + "\n";
+        const res = (0, child_process_1.execSync)("git cat-file --batch-check", {
             cwd: repoRoot,
+            input,
             stdio: ["pipe", "pipe", "pipe"],
-        }).toString().trim();
-        return /^[0-9a-f]{40}$/.test(r) ? r : null;
+        }).toString();
+        const lines = res.split("\n");
+        // One output line per input line, in order: "<full-sha> commit <size>" when
+        // resolved; "<request> missing" / "<request> ambiguous" otherwise.
+        shas.forEach((sha, i) => {
+            const parts = (lines[i] ?? "").trim().split(/\s+/);
+            if (parts.length >= 2 && parts[1] === "commit" && /^[0-9a-f]{40}$/.test(parts[0])) {
+                out.set(sha, parts[0].toLowerCase());
+            }
+        });
     }
     catch {
-        return null;
+        // best-effort — a git failure just means no shas resolve
     }
+    return out;
 }
 // Current branch via direct .git/HEAD read (no git binary required, same
 // robustness as getGitRemoteUrl). Returns null on detached HEAD or when
@@ -665,7 +761,7 @@ function vscodeCopilotInstalled() {
 // with `subcommand`) into the given hook event, stripping any prior codiedev
 // entries first so connect re-runs / upgrades refresh the resolved binary path.
 // Mutates `hooks` in place. Exported for unit testing.
-function upsertCodiedevHook(hooks, eventName, subcommand) {
+function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     if (!hooks[eventName])
         hooks[eventName] = [];
     const existing = hooks[eventName];
@@ -677,7 +773,7 @@ function upsertCodiedevHook(hooks, eventName, subcommand) {
         return !(0, detection_1.isCodiedevHookCommand)(hook.matcher);
     });
     filtered.push({
-        matcher: ".*",
+        matcher,
         hooks: [{ type: "command", command: resolveHookCommand(subcommand) }],
     });
     hooks[eventName] = filtered;
@@ -703,6 +799,8 @@ function installHook() {
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover");
     // Stop → backup (auto-back-up changed artifact files to your private library).
     upsertCodiedevHook(hooks, "Stop", "backup");
+    // StopFailure (matcher rate_limit) → limit (post rate-limit event to the team).
+    upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
     if (!fs.existsSync(CLAUDE_DIR)) {
         fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
@@ -758,6 +856,29 @@ function ensureBackupHookInstalled() {
     }
     catch { /* best-effort */ }
 }
+// Self-heal: ensure the StopFailure (matcher rate_limit) → limit hook is
+// present without a full `connect` re-run, mirroring ensureBackupHookInstalled.
+// Called from the capture hook so an upgraded-but-not-reconnected user gets the
+// limit-event hook wired on their next session. Only writes when missing.
+function ensureLimitHookInstalled() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
+            return;
+        const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
+        const hooks = (settings.hooks ?? {});
+        const sf = (hooks.StopFailure ?? []);
+        const present = sf.some((h) => {
+            const inner = h.hooks;
+            return Array.isArray(inner) && inner.some((x) => (0, detection_1.isCodiedevHookCommand)(x.command));
+        });
+        if (present)
+            return;
+        settings.hooks = hooks;
+        upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+    }
+    catch { /* best-effort */ }
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // MCP server installation — writes the codiedev MCP server config into each
 // agent CLI's expected location so "npx codiedev connect" wires it up once.
@@ -1459,6 +1580,20 @@ function extractCodexRepoUrl(content) {
 // failing job never litters /tmp forever. Paired with UPLOAD_TTL_MS.
 exports.MAX_UPLOAD_ATTEMPTS = 5;
 exports.UPLOAD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+// Hand the SessionEnd capture off to a detached child so the inline hook can
+// exit 0 immediately. Detaching only the network upload (dispatchCaptureDetached)
+// wasn't enough: the synchronous transcript read + parse and — the killer on
+// Windows — one `git rev-parse` per SHA in the transcript (parseAuthoredShas)
+// still ran inline, overrunning Claude Code's SessionEnd shutdown window and
+// triggering "Hook cancelled" on long sessions. This moves ALL of that work
+// into the child. The job carries only the raw hook inputs (the child re-reads
+// the transcript and re-runs git), so the parent's inline work is a single
+// small file write plus a spawn.
+function dispatchCaptureFinish(input, hookScriptPath, deps) {
+    deps.writeFileSync(deps.tmpFile, JSON.stringify(input), { mode: 0o600 });
+    const child = deps.spawn(deps.nodePath ?? process.execPath, [hookScriptPath, "capture-finish", deps.tmpFile], { detached: true, stdio: "ignore" });
+    child.unref();
+}
 // Fire-and-forget the session-capture upload from a fully detached child so the
 // SessionEnd hook can exit 0 immediately. Awaiting the upload inline let Claude
 // Code's shutdown window elapse and kill the hook ("Hook cancelled") on large

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",