codiedev 0.9.16 → 0.9.18

package/dist/captureReadiness.d.ts

@@ -15,6 +15,17 @@ export interface CaptureReadiness {
     headSha: string | null;
 }
 export declare function assessCaptureReadiness<R>(cwd: string, repos: R[], deps: CaptureReadinessDeps<R>): CaptureReadiness;
+export interface WorkspaceRepoScanDeps<R = unknown> {
+    listChildDirs: (cwd: string) => string[];
+    isRepo: (dir: string) => boolean;
+    getRemoteUrl: (dir: string) => string | null;
+    matchRepo: (url: string, repos: R[]) => R | null;
+}
+export interface WorkspaceRepoScan {
+    repoCount: number;
+    matchedCount: number;
+}
+export declare function assessWorkspaceRepos<R>(cwd: string, repos: R[], deps: WorkspaceRepoScanDeps<R>): WorkspaceRepoScan;
 export declare function formatRelativeAge(ms: number): string;
 export interface LastCaptureSummary {
     status: "pass" | "warn";

package/dist/captureReadiness.js

@@ -8,6 +8,7 @@
 // production wiring (in doctor.ts) plugs in execSync + the real git helpers.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assessCaptureReadiness = assessCaptureReadiness;
+exports.assessWorkspaceRepos = assessWorkspaceRepos;
 exports.formatRelativeAge = formatRelativeAge;
 exports.summarizeLastCapture = summarizeLastCapture;
 exports.summarizeServerCapture = summarizeServerCapture;
@@ -41,6 +42,26 @@ function assessCaptureReadiness(cwd, repos, deps) {
         headSha: deps.getHeadSha(cwd),
     };
 }
+function assessWorkspaceRepos(cwd, repos, deps) {
+    let childDirs;
+    try {
+        childDirs = deps.listChildDirs(cwd);
+    }
+    catch {
+        return { repoCount: 0, matchedCount: 0 };
+    }
+    let repoCount = 0;
+    let matchedCount = 0;
+    for (const dir of childDirs) {
+        if (!deps.isRepo(dir))
+            continue;
+        repoCount++;
+        const url = deps.getRemoteUrl(dir);
+        if (url && deps.matchRepo(url, repos) !== null)
+            matchedCount++;
+    }
+    return { repoCount, matchedCount };
+}
 function formatRelativeAge(ms) {
     if (ms < 0)
         ms = 0;

package/dist/commands/doctor.js

@@ -224,6 +224,23 @@ async function runDoctor(_args) {
         getBranch: utils_1.getGitBranch,
         getHeadSha: utils_1.getGitHeadSha,
     });
+    // Workspace-root mode: the cwd isn't a repo itself, but git repos sit
+    // directly under it (one `.devcontainer/` at a parent folder of several
+    // cloned repos). Capture tags the sub-repo a session edits, so report that
+    // instead of flatly warning "not a work tree / no remote" — the exact output
+    // that made working workspace-root setups read as broken.
+    const workspaceScan = readiness.gitOnPath && !readiness.insideWorkTree
+        ? (0, captureReadiness_1.assessWorkspaceRepos)(cwd, config.repos ?? [], {
+            listChildDirs: (dir) => fs
+                .readdirSync(dir, { withFileTypes: true })
+                .filter((e) => e.isDirectory())
+                .map((e) => path.join(dir, e.name)),
+            isRepo: (dir) => fs.existsSync(path.join(dir, ".git")),
+            getRemoteUrl: utils_1.getGitRemoteUrl,
+            matchRepo: utils_1.matchRepo,
+        })
+        : { repoCount: 0, matchedCount: 0 };
+    const workspaceMode = workspaceScan.repoCount > 0;
     checks.push({
         name: "git on PATH",
         status: readiness.gitOnPath ? "pass" : "fail",
@@ -233,26 +250,34 @@ async function runDoctor(_args) {
     });
     checks.push({
         name: "Inside a git work tree (current dir)",
-        status: readiness.insideWorkTree ? "pass" : "warn",
+        status: readiness.insideWorkTree || workspaceMode ? "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",
+            : workspaceMode
+                ? `workspace root — ${workspaceScan.repoCount} git repo${workspaceScan.repoCount === 1 ? "" : "s"} directly under it; sessions tag the repo they edit`
+                : "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",
+        status: readiness.matched || workspaceScan.matchedCount > 0 ? "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",
+            : workspaceMode
+                ? workspaceScan.matchedCount > 0
+                    ? `${workspaceScan.matchedCount} of ${workspaceScan.repoCount} workspace repos are tracked`
+                    : `none of the ${workspaceScan.repoCount} workspace repos are tracked — link them in the portal`
+                : 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",
+        status: readiness.branch || readiness.headSha || workspaceMode ? "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",
+            : workspaceMode
+                ? "branch/sha resolve from the sub-repo each session writes to"
+                : "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

package/dist/hook.js

@@ -112,10 +112,15 @@ async function runStopFailure(hookInput) {
     if (!config)
         process.exit(0);
     let event = null;
+    let transcriptTail;
     const tp = hookInput.transcript_path;
     if (tp) {
         try {
-            event = (0, limitEvent_1.parseLimitEventFromTranscript)(fs.readFileSync(tp, "utf8"));
+            const transcript = fs.readFileSync(tp, "utf8");
+            event = (0, limitEvent_1.parseLimitEventFromTranscript)(transcript);
+            // Ship the tail with the event so the server can summarize "what they
+            // were working on" right now — no waiting for the SessionEnd capture.
+            transcriptTail = (0, limitEvent_1.tailForLimitEvent)(transcript) || undefined;
         }
         catch {
             /* unreadable transcript — fall through to minimal event */
@@ -130,6 +135,7 @@ async function runStopFailure(hookInput) {
             at: payload.at,
             resetText: payload.resetText,
             sessionId: hookInput.session_id,
+            transcriptTail,
         }, config.token);
     }
     catch {
@@ -377,8 +383,13 @@ async function runCaptureFinish(input) {
     if (mode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
+    // The worktrees the session actually wrote to — resolved up front because
+    // they both anchor the branch/sha join keys below AND back-fill the repo tag
+    // when the launch dir is a multi-repo WORKSPACE root (a parent folder of
+    // several cloned repos) that has no remote of its own.
+    const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
     if (!remoteUrl) {
-        remoteUrl = (0, utils_1.getGitRemoteUrl)(workspaceRoot);
+        remoteUrl = (0, utils_1.resolveCaptureRemoteUrl)(workspaceRoot, captureDirs);
     }
     // Capture-first: the transcript is the asset; the repo is just a tag. We do
     // NOT bail when `remoteUrl` is null — that previously dropped EVERY session
@@ -403,7 +414,6 @@ async function runCaptureFinish(input) {
     // One session can touch several worktrees (→ several PRs); capture EVERY
     // 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 keys = (0, utils_1.collectCaptureKeys)(captureDirs);
     // Union the worktree-dir branches with the branches the agent actually
     // committed/pushed to (parsed from the transcript's git output). Like the

package/dist/limitEvent.d.ts

@@ -6,3 +6,4 @@ export interface LimitEvent {
 }
 export declare function classifyLimitKind(text: string): LimitKind;
 export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;
+export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;

package/dist/limitEvent.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLimitKind = classifyLimitKind;
 exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
+exports.tailForLimitEvent = tailForLimitEvent;
 function classifyLimitKind(text) {
     const t = text.toLowerCase();
     if (t.includes("session limit"))
@@ -49,3 +50,15 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
+// Tail of the raw transcript to ship with the limit event so the server can
+// summarize "what they were working on" immediately — without waiting for the
+// SessionEnd capture (which can lag hours, or drop entirely on Windows).
+// Resumes at a line boundary so every JSONL line in the tail still parses.
+const DEFAULT_TAIL_CHARS = 65536;
+function tailForLimitEvent(transcript, maxChars = DEFAULT_TAIL_CHARS) {
+    if (transcript.length <= maxChars)
+        return transcript;
+    const sliced = transcript.slice(-maxChars);
+    const nl = sliced.indexOf("\n");
+    return nl === -1 ? sliced : sliced.slice(nl + 1);
+}

package/dist/utils.d.ts

@@ -17,6 +17,7 @@ export declare function writeConfig(config: CodiedevConfig): void;
 export declare function parseGitRemoteFromConfig(configText: string): string | null;
 export declare function readGitRemoteFromConfig(startDir: string): string | null;
 export declare function getGitRemoteUrl(cwd: string): string | null;
+export declare function resolveCaptureRemoteUrl(workspaceRoot: string, captureDirs: string[], getRemote?: (dir: string) => string | null): string | null;
 export declare function normalizeRepoUrl(url: string): string;
 export declare function matchRepo(remoteUrl: string, repos: Array<{
     repoId: string;

package/dist/utils.js

@@ -39,6 +39,7 @@ exports.writeConfig = writeConfig;
 exports.parseGitRemoteFromConfig = parseGitRemoteFromConfig;
 exports.readGitRemoteFromConfig = readGitRemoteFromConfig;
 exports.getGitRemoteUrl = getGitRemoteUrl;
+exports.resolveCaptureRemoteUrl = resolveCaptureRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
 exports.resolveCaptureDir = resolveCaptureDir;
@@ -235,6 +236,24 @@ function getGitRemoteUrl(cwd) {
         return null;
     }
 }
+// Resolve the remote that tags the session's repo. The workspace root is the
+// primary source, but when the session was launched at a multi-repo WORKSPACE
+// root — a parent folder holding several cloned repos with `.devcontainer/` at
+// the top, which is not itself a git repo — the root has no remote, and tagging
+// used to silently produce repo-UNMATCHED sessions. Fall back to the worktrees
+// the session actually wrote to (resolveCaptureDirs order: most-recent first),
+// so the session tags the repo the work happened in.
+function resolveCaptureRemoteUrl(workspaceRoot, captureDirs, getRemote = getGitRemoteUrl) {
+    const fromRoot = getRemote(workspaceRoot);
+    if (fromRoot)
+        return fromRoot;
+    for (const dir of captureDirs) {
+        const url = getRemote(dir);
+        if (url)
+            return url;
+    }
+    return null;
+}
 function normalizeRepoUrl(url) {
     // Normalize SSH (git@github.com:org/repo.git) and HTTPS (https://github.com/org/repo.git)
     // to a comparable form: github.com/org/repo

package/package.json

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