codiedev 0.9.11 → 0.9.13

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);

package/dist/utils.d.ts

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

@@ -81,6 +81,9 @@ exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
 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"));
@@ -285,40 +288,49 @@ function resolveCaptureDir(transcriptContent, workspaceRoot) {
 // used (work done directly in the repo).
 function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     const rootGitDir = resolveGitDir(workspaceRoot);
-    // 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.
+    // 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));
     };
-    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;
+        let entry;
         try {
-            const entry = JSON.parse(line);
-            if (typeof entry?.cwd === "string" && entry.cwd)
-                add(entry.cwd);
+            entry = JSON.parse(line);
         }
         catch {
-            // non-JSON / partial line — still scan the raw text below
+            // partial/non-JSON line — best-effort: only mutating git -C, never files.
+            for (const d of mutatingGitCDirs(line))
+                add(d);
+            continue;
         }
-        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]}"`)));
+        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));
             }
-            catch { /* skip */ }
         }
     }
     // Walk most-recent first; one entry per distinct worktree gitdir (a worktree's
@@ -338,6 +350,23 @@ function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     }
     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) {
@@ -1466,6 +1495,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
@@ -1485,7 +1553,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.11",
+  "version": "0.9.13",
   "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",