codiedev 0.9.10 → 0.9.12

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,96 @@ function resolveCaptureDir(transcriptContent, workspaceRoot) {
 // used (work done directly in the repo).
 function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     const rootGitDir = resolveGitDir(workspaceRoot);
-    const cwds = [];
+    // Collect the folders the session WROTE to (not merely referenced), in order:
+    //   - the session cwd
+    //   - `git -C <path>` of MUTATING git commands (commit/push/add/...) — NOT
+    //     read-only ones (log/status/diff), which would falsely credit a worktree
+    //     the session only inspected
+    //   - the dir of files edited via Edit/Write/NotebookEdit — NOT Read/Grep/Glob
+    // Reading/inspecting another worktree must not attribute its PRs to this
+    // session (that also corrupts the even cost-split).
+    const candidates = [];
+    const add = (p) => {
+        if (!p)
+            return;
+        candidates.push(path.isAbsolute(p) ? p : path.resolve(workspaceRoot, p));
+    };
     for (const line of transcriptContent.split("\n")) {
         if (!line.trim())
             continue;
+        let entry;
         try {
-            const entry = JSON.parse(line);
-            if (typeof entry?.cwd === "string" && entry.cwd)
-                cwds.push(entry.cwd);
+            entry = JSON.parse(line);
         }
         catch {
-            // non-JSON / partial line — skip
+            // partial/non-JSON line — best-effort: only mutating git -C, never files.
+            for (const d of mutatingGitCDirs(line))
+                add(d);
+            continue;
+        }
+        if (typeof entry?.cwd === "string" && entry.cwd)
+            add(entry.cwd);
+        const content = entry?.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const b of content) {
+            if (b?.type !== "tool_use")
+                continue;
+            if (b.name === "Bash" && typeof b.input?.command === "string") {
+                for (const d of mutatingGitCDirs(b.input.command))
+                    add(d);
+            }
+            else if ((b.name === "Edit" || b.name === "Write" || b.name === "NotebookEdit") &&
+                typeof (b.input?.file_path ?? b.input?.notebook_path) === "string") {
+                add(path.dirname(b.input.file_path ?? b.input.notebook_path));
+            }
         }
     }
-    // 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];
 }
+// Extract the `-C <path>` targets of MUTATING git commands in a shell string.
+// Splits on command separators and only takes a sub-command's -C path when that
+// sub-command runs a state-changing git verb — so `git -C x log` is ignored but
+// `git -C x commit`/`push`/`add` count.
+const MUTATING_GIT = /\b(?:commit|push|add|checkout|switch|merge|rebase|reset|restore|rm|mv|stash|apply|cherry-pick|am|tag|worktree)\b/;
+function mutatingGitCDirs(command) {
+    const out = [];
+    for (const sub of command.split(/&&|\|\||;|\n/)) {
+        if (!/\bgit\b/.test(sub) || !MUTATING_GIT.test(sub))
+            continue;
+        const re = /-C\s+(?:"([^"]+)"|'([^']+)'|(\S+))/g;
+        let m;
+        while ((m = re.exec(sub)))
+            out.push(m[1] ?? m[2] ?? m[3]);
+    }
+    return out;
+}
+// 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 +392,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.12",
   "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",