codiedev 0.9.10 → 0.9.11

package/dist/hook.js

@@ -263,7 +263,15 @@ async function main() {
     // worktree's branch+sha so all the resulting PRs attribute. branch/headSha
     // remain the primary (most-recent) values for back-compat.
     const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
-    const { branch, headSha, branches, headShas } = (0, utils_1.collectCaptureKeys)(captureDirs);
+    const keys = (0, utils_1.collectCaptureKeys)(captureDirs);
+    const { branch, branches } = keys;
+    // 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
+    // filesystem state, so they rescue attribution when a worktree is stale/gone.
+    const authoredShas = (0, utils_1.parseAuthoredShas)(transcriptContent, workspaceRoot);
+    const headShas = [...new Set([...keys.headShas, ...authoredShas])];
+    const headSha = keys.headSha ?? headShas[0] ?? null;
     // Cost/velocity/steering signals parsed straight from the transcript we're
     // already holding — no extra hooks, no extra git/process calls.
     const usage = (0, utils_1.parseUsage)(transcriptContent, mode);

package/dist/utils.d.ts

@@ -35,6 +35,8 @@ export declare function collectCaptureKeys(dirs: string[], getBranch?: (d: strin
     branches: string[];
     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 getGitBranch(cwd: string): string | null;
 export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {

package/dist/utils.js

@@ -44,6 +44,8 @@ exports.matchRepo = matchRepo;
 exports.resolveCaptureDir = resolveCaptureDir;
 exports.resolveCaptureDirs = resolveCaptureDirs;
 exports.collectCaptureKeys = collectCaptureKeys;
+exports.extractShaTokens = extractShaTokens;
+exports.parseAuthoredShas = parseAuthoredShas;
 exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
@@ -283,35 +285,70 @@ function resolveCaptureDir(transcriptContent, workspaceRoot) {
 // used (work done directly in the repo).
 function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     const rootGitDir = resolveGitDir(workspaceRoot);
-    const cwds = [];
+    // Collect EVERY filesystem path the session referenced, in order — not just
+    // the session cwd. An agent can touch a worktree without cd-ing into it:
+    //   - `git -C <path> ...`            (operate on a worktree by path)
+    //   - editing a file inside it       ("file_path": "<worktree>/src/x.ts")
+    // Catching all of these is what makes worktree detection robust.
+    const candidates = [];
+    const add = (p) => {
+        if (!p)
+            return;
+        candidates.push(path.isAbsolute(p) ? p : path.resolve(workspaceRoot, p));
+    };
+    const gitCRe = /git\s+(?:[^\s]+\s+)*?-C\s+(?:"([^"]+)"|'([^']+)'|(\S+))/g;
+    const filePathRe = /"file_path"\s*:\s*"((?:[^"\\]|\\.)+)"/g;
     for (const line of transcriptContent.split("\n")) {
         if (!line.trim())
             continue;
         try {
             const entry = JSON.parse(line);
             if (typeof entry?.cwd === "string" && entry.cwd)
-                cwds.push(entry.cwd);
+                add(entry.cwd);
         }
         catch {
-            // non-JSON / partial line — skip
+            // non-JSON / partial line — still scan the raw text below
+        }
+        let m;
+        gitCRe.lastIndex = 0;
+        while ((m = gitCRe.exec(line)))
+            add(m[1] ?? m[2] ?? m[3]);
+        filePathRe.lastIndex = 0;
+        while ((m = filePathRe.exec(line))) {
+            try {
+                add(path.dirname(JSON.parse(`"${m[1]}"`)));
+            }
+            catch { /* skip */ }
         }
     }
-    // Walk most-recent first; keep one entry per distinct worktree gitdir (a
-    // worktree's gitdir is .git/worktrees/<name>; the root and its subdirs share
-    // .git, so they're excluded as not-separate).
+    // Walk most-recent first; one entry per distinct worktree gitdir (a worktree's
+    // gitdir is .git/worktrees/<name>; the root and its subdirs share .git, so
+    // they're excluded as not-separate). Normalize each to its canonical worktree
+    // root so a file path / subdir resolves to the worktree dir itself.
     const out = [];
     const seenGitDirs = new Set();
-    for (let i = cwds.length - 1; i >= 0; i--) {
-        const gitDir = resolveGitDir(cwds[i]);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const gitDir = resolveGitDir(candidates[i]);
         if (!gitDir || (rootGitDir && gitDir === rootGitDir))
             continue;
         if (seenGitDirs.has(gitDir))
             continue;
         seenGitDirs.add(gitDir);
-        out.push(cwds[i]);
+        out.push(worktreeRootFromGitDir(gitDir) ?? candidates[i]);
     }
     return out.length > 0 ? out : [workspaceRoot];
 }
+// A linked worktree's gitdir (`.git/worktrees/<name>`) holds a `gitdir` file
+// pointing at the worktree's own `.git` file; its parent is the worktree root.
+function worktreeRootFromGitDir(gitDir) {
+    try {
+        const p = fs.readFileSync(path.join(gitDir, "gitdir"), "utf8").trim();
+        return p ? path.dirname(p) : null;
+    }
+    catch {
+        return null;
+    }
+}
 // Turn the worktrees a session touched into the upload join keys: dedup'd
 // branch + headSha arrays (so one session → many PRs all attribute), plus the
 // primary single values (first entry) for back-compat with servers that read
@@ -329,6 +366,58 @@ function collectCaptureKeys(dirs, getBranch = getGitBranch, getSha = getGitHeadS
     }
     return { branch: branches[0] ?? null, headSha: headShas[0] ?? null, branches, headShas };
 }
+// Pull the commit SHAs the agent actually authored/pushed straight out of the
+// transcript's git command OUTPUT — independent of end-of-session filesystem
+// state. Catches: commit output "[branch 4c4e790]", push ranges
+// "abc1234..def5678", and bare 40-hex (rev-parse). This is the signal that
+// rescues attribution when the worktree's HEAD is stale or the worktree is gone
+// at SessionEnd (pruned worktree, submodule pointer bump).
+function extractShaTokens(transcriptContent) {
+    const out = new Set();
+    const commitRe = /\[[^\]\n]*?\b([0-9a-f]{7,40})\]/g; // [branch <sha>]
+    const rangeRe = /\b([0-9a-f]{7,40})\.\.([0-9a-f]{7,40})\b/g; // <sha>..<sha>
+    const fullRe = /\b([0-9a-f]{40})\b/g; // bare full sha (rev-parse)
+    let m;
+    while ((m = commitRe.exec(transcriptContent)))
+        out.add(m[1].toLowerCase());
+    while ((m = rangeRe.exec(transcriptContent))) {
+        out.add(m[1].toLowerCase());
+        out.add(m[2].toLowerCase());
+    }
+    while ((m = fullRe.exec(transcriptContent)))
+        out.add(m[1].toLowerCase());
+    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)) {
+    const out = new Set();
+    for (const tok of extractShaTokens(transcriptContent)) {
+        if (tok.length === 40) {
+            out.add(tok);
+            continue;
+        }
+        const full = resolveFull(tok);
+        if (full && /^[0-9a-f]{40}$/.test(full))
+            out.add(full.toLowerCase());
+    }
+    return [...out];
+}
+function defaultResolveFullSha(sha, repoRoot) {
+    try {
+        const r = (0, child_process_1.execSync)(`git rev-parse ${sha}^{commit}`, {
+            cwd: repoRoot,
+            stdio: ["pipe", "pipe", "pipe"],
+        }).toString().trim();
+        return /^[0-9a-f]{40}$/.test(r) ? r : null;
+    }
+    catch {
+        return null;
+    }
+}
 // Current branch via direct .git/HEAD read (no git binary required, same
 // robustness as getGitRemoteUrl). Returns null on detached HEAD or when
 // unresolvable. This is the session→merge join key: a captured session's

package/package.json

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