codiedev 0.9.12 → 0.9.14

package/dist/captureReadiness.d.ts

@@ -0,0 +1,36 @@
+import type { LastCaptureRecord } from "./utils";
+export interface CaptureReadinessDeps<R = unknown> {
+    exec: (cmd: string, cwd: string) => string;
+    getRemoteUrl: (cwd: string) => string | null;
+    matchRepo: (url: string, repos: R[]) => R | null;
+    getBranch: (cwd: string) => string | null;
+    getHeadSha: (cwd: string) => string | null;
+}
+export interface CaptureReadiness {
+    gitOnPath: boolean;
+    insideWorkTree: boolean;
+    remoteUrl: string | null;
+    matched: boolean;
+    branch: string | null;
+    headSha: string | null;
+}
+export declare function assessCaptureReadiness<R>(cwd: string, repos: R[], deps: CaptureReadinessDeps<R>): CaptureReadiness;
+export declare function formatRelativeAge(ms: number): string;
+export interface LastCaptureSummary {
+    status: "pass" | "warn";
+    detail: string;
+}
+export declare function summarizeLastCapture(record: LastCaptureRecord | null, nowMs: number): LastCaptureSummary;
+export interface ServerCaptureResponse {
+    found: boolean;
+    latest: {
+        sessionId: string;
+        capturedAt: number;
+        createdAt: number;
+        repoMatched: boolean;
+        branch: string | null;
+        headSha: string | null;
+    } | null;
+    sessionFound?: boolean;
+}
+export declare function summarizeServerCapture(server: ServerCaptureResponse | null, local: LastCaptureRecord | null, nowMs: number): LastCaptureSummary;

package/dist/captureReadiness.js

@@ -0,0 +1,107 @@
+"use strict";
+// Capture-readiness assessment for `codiedev doctor`. Answers: "from where I'm
+// standing right now, would a session actually capture?" — the blind spot that
+// let lean-container / submodule / no-remote setups silently produce zero
+// sessions while doctor's setup checks stayed green.
+//
+// Pure + fully injectable so it unit-tests without a real git repo. The default
+// production wiring (in doctor.ts) plugs in execSync + the real git helpers.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessCaptureReadiness = assessCaptureReadiness;
+exports.formatRelativeAge = formatRelativeAge;
+exports.summarizeLastCapture = summarizeLastCapture;
+exports.summarizeServerCapture = summarizeServerCapture;
+function assessCaptureReadiness(cwd, repos, deps) {
+    let gitOnPath = false;
+    try {
+        deps.exec("git --version", cwd);
+        gitOnPath = true;
+    }
+    catch {
+        gitOnPath = false;
+    }
+    let insideWorkTree = false;
+    if (gitOnPath) {
+        try {
+            const out = deps.exec("git rev-parse --is-inside-work-tree", cwd);
+            insideWorkTree = out.trim() === "true";
+        }
+        catch {
+            insideWorkTree = false;
+        }
+    }
+    const remoteUrl = deps.getRemoteUrl(cwd);
+    const matched = remoteUrl ? deps.matchRepo(remoteUrl, repos) !== null : false;
+    return {
+        gitOnPath,
+        insideWorkTree,
+        remoteUrl,
+        matched,
+        branch: deps.getBranch(cwd),
+        headSha: deps.getHeadSha(cwd),
+    };
+}
+function formatRelativeAge(ms) {
+    if (ms < 0)
+        ms = 0;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h`;
+    return `${Math.floor(h / 24)}d`;
+}
+// Turns the "last session captured" breadcrumb into a doctor line. This is the
+// payoff check: it lets a user confirm their most recent session actually
+// landed without opening the portal.
+function summarizeLastCapture(record, nowMs) {
+    if (!record) {
+        return {
+            status: "warn",
+            detail: "no session captured yet from this machine — run a session, exit, then re-run `codiedev doctor`",
+        };
+    }
+    const age = formatRelativeAge(nowMs - record.recordedAt);
+    if (!record.matched) {
+        return {
+            status: "warn",
+            detail: `last session captured ${age} ago, but NOT matched to a tracked repo (${record.repoUrl || "no remote"}) — link the repo in the portal`,
+        };
+    }
+    return { status: "pass", detail: `last session captured ${age} ago` };
+}
+// Server-confirmed "did my last session land?". Prefers portal truth over the
+// local 2xx breadcrumb; the highest-value branch is "uploaded locally but the
+// portal has no record" — the exact silent failure devs hit (2xx to nothing,
+// wrong identity, backend drop).
+function summarizeServerCapture(server, local, nowMs) {
+    // Endpoint unavailable / old backend → fall back to the local breadcrumb.
+    if (server === null)
+        return summarizeLastCapture(local, nowMs);
+    if (server.found && server.latest) {
+        const age = formatRelativeAge(nowMs - server.latest.createdAt);
+        if (!server.latest.repoMatched) {
+            return {
+                status: "warn",
+                detail: `last session is in the portal (${age} ago) but NOT matched to a tracked repo — link the repo in the portal`,
+            };
+        }
+        return { status: "pass", detail: `confirmed in the portal — last session captured ${age} ago` };
+    }
+    // Server reachable but has no session for this user.
+    if (local) {
+        const age = formatRelativeAge(nowMs - local.recordedAt);
+        return {
+            status: "warn",
+            detail: `uploaded from this machine ${age} ago but NOT found in the portal — capture isn't landing (check \`codiedev connect\`, token, and that the repo is linked)`,
+        };
+    }
+    return {
+        status: "warn",
+        detail: "no session captured yet from this machine — run a session, exit, then re-run `codiedev doctor`",
+    };
+}

package/dist/commands/doctor.js

@@ -43,6 +43,7 @@ const utils_1 = require("../utils");
 const detection_1 = require("../detection");
 const version_1 = require("../version");
 const upgradeNudge_1 = require("../upgradeNudge");
+const captureReadiness_1 = require("../captureReadiness");
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
@@ -210,6 +211,80 @@ async function runDoctor(_args) {
             ? `${repoCount} repo${repoCount === 1 ? "" : "s"}`
             : "0 — link repos in the portal so sessions get captured",
     });
+    // 4b. Capture readiness — the part that actually decides whether a session
+    // lands. doctor used to verify only that the hook was *installed*; these
+    // checks answer "from this directory, would a session capture, and did my
+    // last one?" — the blind spot behind lean-container / submodule / no-remote
+    // zeros.
+    const cwd = process.cwd();
+    const readiness = (0, captureReadiness_1.assessCaptureReadiness)(cwd, config.repos ?? [], {
+        exec: (cmd, dir) => (0, child_process_1.execSync)(cmd, { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }).toString(),
+        getRemoteUrl: utils_1.getGitRemoteUrl,
+        matchRepo: utils_1.matchRepo,
+        getBranch: utils_1.getGitBranch,
+        getHeadSha: utils_1.getGitHeadSha,
+    });
+    checks.push({
+        name: "git on PATH",
+        status: readiness.gitOnPath ? "pass" : "fail",
+        detail: readiness.gitOnPath
+            ? undefined
+            : "not found — capture can't tag sessions to a repo (install git, e.g. `apk add git`)",
+    });
+    checks.push({
+        name: "Inside a git work tree (current dir)",
+        status: readiness.insideWorkTree ? "pass" : "warn",
+        detail: readiness.insideWorkTree
+            ? undefined
+            : "current dir isn't a git work tree — if your repo is a mounted submodule, mount the full project so its .git is present",
+    });
+    checks.push({
+        name: "Current repo resolves to a tracked repo",
+        status: readiness.matched ? "pass" : "warn",
+        detail: readiness.matched
+            ? `${readiness.remoteUrl}`
+            : readiness.remoteUrl
+                ? `remote ${readiness.remoteUrl} isn't a tracked repo — link it in the portal`
+                : "no origin remote here — capture uploads but won't link to a repo",
+    });
+    checks.push({
+        name: "What this session would capture",
+        status: readiness.branch || readiness.headSha ? "pass" : "warn",
+        detail: readiness.branch || readiness.headSha
+            ? `branch ${readiness.branch ?? "—"} @ ${(readiness.headSha ?? "—").slice(0, 8)}`
+            : "no branch/sha resolved — session→merge attribution will be weaker",
+    });
+    // 4c. The payoff: did the last session actually land? Ask the server for
+    // portal truth (does the row exist for this user?), falling back to the local
+    // 2xx breadcrumb if the endpoint is unreachable or predates this CLI/backend.
+    const localMarker = (0, utils_1.readLastCapture)();
+    let server = null;
+    try {
+        const u = new URL(`${config.backendUrl}/api/cli/lastCapture`);
+        if (localMarker?.sessionId)
+            u.searchParams.set("sessionId", localMarker.sessionId);
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 3000);
+        const res = await fetch(u.toString(), {
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+            },
+            signal: ctrl.signal,
+        });
+        clearTimeout(timer);
+        if (res.ok)
+            server = (await res.json());
+    }
+    catch {
+        server = null; // unreachable / old backend → fall back to the local marker
+    }
+    const lastCapture = (0, captureReadiness_1.summarizeServerCapture)(server, localMarker, Date.now());
+    checks.push({
+        name: "Last session captured",
+        status: lastCapture.status,
+        detail: lastCapture.detail,
+    });
     // 5. Claude Code setup (if present)
     if ((0, utils_1.claudeCodeInstalled)()) {
         checks.push({

package/dist/hook.js

@@ -171,6 +171,9 @@ async function main() {
                 // Persist a bumped attempt count on failure so a later sweep retries
                 // (instead of dropping a session on a transient network blip).
                 writeFileSync: fs.writeFileSync,
+                // On a successful upload, drop the "last session captured" breadcrumb
+                // that `codiedev doctor` reads to confirm the session landed.
+                recordSuccess: (job) => (0, utils_1.writeLastCapture)((0, utils_1.buildLastCaptureRecord)(job, Date.now())),
             });
         }
         process.exit(0);
@@ -183,6 +186,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();
@@ -198,10 +229,10 @@ async function main() {
         await runDiscover(hookInput.prompt);
         return;
     }
-    const mode = resolveMode(process.argv[2]);
     // 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.
+    // 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)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
@@ -216,6 +247,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);
@@ -223,12 +263,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.
@@ -264,7 +337,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
@@ -299,11 +381,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`);
@@ -321,7 +401,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/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 {
@@ -171,6 +172,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;
@@ -188,6 +197,29 @@ interface UploadDeps {
     unlinkSync: typeof fs.unlinkSync;
     writeFileSync?: typeof fs.writeFileSync;
     now?: () => number;
+    recordSuccess?: (job: CaptureUploadJob) => void;
+}
+export interface LastCaptureRecord {
+    sessionId: string | undefined;
+    repoUrl: string;
+    matched: boolean;
+    branch: string;
+    headSha: string;
+    source: string;
+    capturedAt: number | undefined;
+    recordedAt: number;
+}
+export declare function buildLastCaptureRecord(job: CaptureUploadJob, now: number): LastCaptureRecord;
+interface LastCaptureWriteDeps {
+    writeFileSync: typeof fs.writeFileSync;
+    existsSync: typeof fs.existsSync;
+    mkdirSync: typeof fs.mkdirSync;
+}
+export declare function writeLastCapture(record: LastCaptureRecord, deps?: LastCaptureWriteDeps, filePath?: string): void;
+interface LastCaptureReadDeps {
+    readFileSync: typeof fs.readFileSync;
+    existsSync: typeof fs.existsSync;
 }
+export declare function readLastCapture(deps?: LastCaptureReadDeps, filePath?: string): LastCaptureRecord | null;
 export declare function runCaptureUpload(jobFile: string, deps: UploadDeps): Promise<void>;
 export {};

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;
@@ -79,8 +80,12 @@ exports.parseSessionStart = parseSessionStart;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
+exports.dispatchCaptureFinish = dispatchCaptureFinish;
 exports.dispatchCaptureDetached = dispatchCaptureDetached;
 exports.sweepPendingCaptures = sweepPendingCaptures;
+exports.buildLastCaptureRecord = buildLastCaptureRecord;
+exports.writeLastCapture = writeLastCapture;
+exports.readLastCapture = readLastCapture;
 exports.runCaptureUpload = runCaptureUpload;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -253,9 +258,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;
         }
     }
@@ -414,35 +423,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
@@ -1456,6 +1554,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
@@ -1492,6 +1604,45 @@ function sweepPendingCaptures(deps) {
         }
     }
 }
+// "Last session captured" breadcrumb. Written next to config.json on a
+// successful capture upload; read by `codiedev doctor` so a user can confirm
+// their most recent session actually landed (the single hardest thing to
+// self-verify today — it previously required eyeballing the portal).
+const LAST_CAPTURE_PATH = path.join(CONFIG_DIR, "last-capture.json");
+function buildLastCaptureRecord(job, now) {
+    const b = job.body;
+    return {
+        sessionId: b.sessionId,
+        repoUrl: b.repoUrl ?? "",
+        matched: Boolean(b.repoId),
+        branch: b.branch ?? "",
+        headSha: b.headSha ?? "",
+        source: b.source ?? "",
+        capturedAt: b.capturedAt,
+        recordedAt: now,
+    };
+}
+function writeLastCapture(record, deps = fs, filePath = LAST_CAPTURE_PATH) {
+    try {
+        const dir = path.dirname(filePath);
+        if (!deps.existsSync(dir))
+            deps.mkdirSync(dir, { recursive: true });
+        deps.writeFileSync(filePath, JSON.stringify(record), { mode: 0o600 });
+    }
+    catch {
+        // breadcrumb is best-effort — never throw on the capture path.
+    }
+}
+function readLastCapture(deps = fs, filePath = LAST_CAPTURE_PATH) {
+    try {
+        if (!deps.existsSync(filePath))
+            return null;
+        return JSON.parse(deps.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
 // Runs inside the detached child spawned by `dispatchCaptureDetached`: read the
 // persisted job, POST it, and ALWAYS delete the temp file afterwards (even on
 // failure) so we don't litter the tmp dir. Never throws — capture is
@@ -1511,7 +1662,14 @@ async function runCaptureUpload(jobFile, deps) {
     }
     try {
         await deps.post(job.url, job.body, job.token);
-        // success — remove the job.
+        // success — drop a "last session captured" breadcrumb (before removing the
+        // job) so doctor can confirm the most recent session actually landed.
+        if (deps.recordSuccess) {
+            try {
+                deps.recordSuccess(job);
+            }
+            catch { /* breadcrumb is best-effort */ }
+        }
         try {
             deps.unlinkSync(jobFile);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "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",