@vibe-commit/capture 0.6.1 → 0.8.0

package/dist/agents/cursor.js

@@ -17,7 +17,9 @@
  * ⚠ **What is DATA here and what is MEASURED is not the same set**, and the
  * difference is marked on each member below rather than left to a reader.
  */
+import { join } from "node:path";
 import { cursorHooksPath, cursorTranscriptRoot, isCursorTranscript } from "../paths.js";
+import { readEntries, sessionFile, subdirectories } from "./session_listing.js";
 /**
  * ⭐ **MEASURED. `D5`'s SECOND HALF IS ANSWERED (`TODOS[130]`), AND THE ANSWER IS
  * THAT CURSOR IMPOSES NO NUMBER OF ITS OWN.**
@@ -79,6 +81,97 @@ import { cursorHooksPath, cursorTranscriptRoot, isCursorTranscript } from "../pa
  */
 const CURSOR_REGISTERED_MS = 3_000;
 const CURSOR_CLIENT_MS = 2_200;
+/**
+ * The longest folder name Cursor writes verbatim.
+ *
+ * ⛔ **MEASURED (Open Question 3, VS, 2026-10-24), with `cursor-agent`, which
+ * creates the project folder even when it is not logged in.** A name up to 61
+ * characters is kept; a longer one becomes its first 53 characters, `-`, and 7
+ * hex characters (the hash varied with the input, so it is not a constant).
+ */
+export const CURSOR_NAME_LIMIT = 61;
+/**
+ * The folder name Cursor gives a workspace path — Open Question 3.
+ *
+ * ⛔ **THIS IS NOT CLAUDE CODE'S RULE, and the difference is the measurement.**
+ * Every RUN of non-alphanumerics, a literal `--` included, collapses to ONE `-`;
+ * leading and trailing separators are dropped (so `/tmp/q/trail.` is `…-trail`
+ * and there is no leading `-`); case is kept. An emoji and `é'` each gave a single
+ * dash where Claude Code gives two.
+ *
+ * ⚠ **Which makes Cursor's names collide far more:** `a-b`, `a.b`, `a--b` and
+ * `a.b.` are all one folder. The scan's walk encodes every directory entry with
+ * THIS function and matches on the result, so the collapsing applies to every
+ * candidate rather than being assumed away.
+ */
+export function encodeProjectPath(path) {
+    return path.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+ * Is this folder name one Cursor cut and hashed? See `CURSOR_NAME_LIMIT`.
+ *
+ * ⚠ **A hashed name is always exactly 61 long, and so is a verbatim name that
+ * happens to be 61 long** — length alone cannot tell them apart. The test is the
+ * hash's shape too (`-` and 7 hex). A verbatim 61-character name that ends the
+ * same way is read as hashed, which is the safe error: it is skipped and
+ * counted, never matched to a path it might not be.
+ */
+export function isHashedProjectName(name) {
+    return name.length === CURSOR_NAME_LIMIT && /-[0-9a-f]{7}$/.test(name);
+}
+/**
+ * The folder Cursor uses for a window with no workspace open. It is not a path,
+ * so it can never resolve to one and is not worth a "folder no longer exists"
+ * count. Seen by NAME on the author's machine; nothing in it was read.
+ */
+const CURSOR_NO_WORKSPACE = "empty-window";
+/**
+ * Cursor's sessions, by folder — `D11 · A`, `scan`.
+ *
+ * `<root>/<encoded workspace>/agent-transcripts/<cid>/<cid>.jsonl`. Only the
+ * conversation's own file counts: `<cid>/subagents/…` is delegated work that
+ * belongs to the parent (`delegatedTranscripts: "announce"`). A flat
+ * `agent-transcripts/<cid>.jsonl` is accepted too, because `isCursorTranscript`
+ * admits any `.jsonl` at that depth and a count that disagreed with the gate
+ * would be a count of nothing.
+ *
+ * ⛔ Names and times only; see `claudeSessionSource` for the rule and its reason.
+ */
+function cursorSessionSource(home) {
+    const root = cursorTranscriptRoot(home);
+    const folders = [];
+    try {
+        for (const folder of subdirectories(root)) {
+            if (folder.name === CURSOR_NO_WORKSPACE)
+                continue;
+            const transcripts = join(folder.path, "agent-transcripts");
+            const sessions = [];
+            for (const entry of readEntries(transcripts) ?? []) {
+                const file = entry.isDirectory()
+                    ? join(transcripts, entry.name, `${entry.name}.jsonl`)
+                    : entry.name.endsWith(".jsonl")
+                        ? join(transcripts, entry.name)
+                        : null;
+                const session = file === null ? null : sessionFile(file);
+                if (session !== null)
+                    sessions.push(session);
+            }
+            if (sessions.length > 0)
+                folders.push({ name: folder.name, sessions });
+        }
+    }
+    catch {
+        return { kind: "unreadable", reason: "unreadable" };
+    }
+    // Cursor keeps no record of the folders it has run in, so there is no second signal.
+    return {
+        kind: "folders",
+        folders,
+        encode: encodeProjectPath,
+        isHashed: isHashedProjectName,
+        recorded: [],
+    };
+}
 export const CURSOR = {
     id: "cursor",
     transport: "ndjson",
@@ -103,7 +196,22 @@ export const CURSOR = {
     // ⛔ Against the client's `SessionEnd`, `sessionEnd` matched NOTHING — not an
     // error, a `false` — so a Cursor session took no settle on its final turn and
     // lost it permanently. That is the whole of the bug.
-    eventNames: { Stop: "stop", PreCompact: "preCompact", SessionEnd: "sessionEnd" },
+    //
+    // ⛔ **`sessionStart` is STATIC, NOT OBSERVED** (Open Question 1, 2026-10-24).
+    // `cursor-agent` was not logged in, so no session ran; the spelling and the
+    // payload (`conversation_id`, `generation_id`, `model`, `is_background_agent`,
+    // `composer_mode`) come from the CLI bundle 2026.08.11-e8db854, which runs it
+    // for a NEW chat before the first turn. It reads `env` and `additional_context`
+    // from the output — and `additional_context` goes into the agent's context and
+    // is NOT shown to the user. There is no user-visible field, so this client
+    // never uses it to carry a notice: Cursor users learn the state from `status`,
+    // and the first-`Stop` install is kept as the fallback for exactly this reason.
+    eventNames: {
+        Stop: "stop",
+        PreCompact: "preCompact",
+        SessionEnd: "sessionEnd",
+        SessionStart: "sessionStart",
+    },
     // ⛔ `~/.cursor/hooks.json`, and the `cursor` SHAPE — the two are a pair.
     // Read out of the shipped bundle's validator: a top-level numeric `version`
     // is REQUIRED, entries are a FLAT array of hook scripts each needing a
@@ -125,6 +233,11 @@ export const CURSOR = {
             registeredTimeoutMs: CURSOR_REGISTERED_MS,
             clientBudgetMs: CURSOR_CLIENT_MS,
         },
+        // gstack-shortcut(dec-e650afbf): `Stop`'s clocks, no fast path (eng review D7 · B).
+        SessionStart: {
+            registeredTimeoutMs: CURSOR_REGISTERED_MS, // gstack-shortcut(dec-e650afbf)
+            clientBudgetMs: CURSOR_CLIENT_MS, // gstack-shortcut(dec-e650afbf)
+        },
     },
     // ⛔ DECLARED EXPLICITLY, and it is load-bearing now in a way it was not
     // before (D177 §2, §9). `subagentsDir()` would compute
@@ -142,6 +255,7 @@ export const CURSOR = {
     // measurement, not as a fact about the agent. Measuring it is a change to this
     // line and nothing else.
     sessionIdFromEnv: () => null,
+    sessionSource: (home) => cursorSessionSource(home),
     // ⛔ NO `locateCurrentTranscript`, and the omission is the decision — the same
     // one Codex made. Finding the conversation for THIS project would mean munging
     // a workspace path this client is never told, or reading a `cwd` out of the

package/dist/agents/cursor.js.map

@@ -1 +1 @@
-{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../src/agents/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,oBAAoB,GAAG,KAAK,CAAC;AACnC,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAE/B,MAAM,CAAC,MAAM,MAAM,GAAsB;IACvC,EAAE,EAAE,QAAQ;IACZ,SAAS,EAAE,QAAQ;IACnB,8EAA8E;IAC9E,2EAA2E;IAC3E,6EAA6E;IAC7E,uDAAuD;IACvD,cAAc,EAAE,oBAAoB;IACpC,wEAAwE;IACxE,uEAAuE;IACvE,UAAU,EAAE,kBAAkB;IAC9B,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,iEAAiE;IACjE,+EAA+E;IAC/E,mEAAmE;IACnE,EAAE;IACF,8EAA8E;IAC9E,4EAA4E;IAC5E,EAAE;IACF,6EAA6E;IAC7E,8EAA8E;IAC9E,qDAAqD;IACrD,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE;IAChF,yEAAyE;IACzE,4EAA4E;IAC5E,uEAAuE;IACvE,6EAA6E;IAC7E,2EAA2E;IAC3E,uDAAuD;IACvD,yEAAyE;IACzE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE;IACtE,MAAM,EAAE;QACN,IAAI,EAAE;YACJ,mBAAmB,EAAE,oBAAoB;YACzC,cAAc,EAAE,gBAAgB;SACjC;QACD,UAAU,EAAE;YACV,mBAAmB,EAAE,oBAAoB;YACzC,cAAc,EAAE,gBAAgB;SACjC;QACD,UAAU,EAAE;YACV,mBAAmB,EAAE,oBAAoB;YACzC,cAAc,EAAE,gBAAgB;SACjC;KACF;IACD,wEAAwE;IACxE,uDAAuD;IACvD,+EAA+E;IAC/E,+EAA+E;IAC/E,8EAA8E;IAC9E,8EAA8E;IAC9E,+DAA+D;IAC/D,oBAAoB,EAAE,UAAU;IAChC,SAAS,EAAE,QAAQ;IACnB,+EAA+E;IAC/E,6EAA6E;IAC7E,6EAA6E;IAC7E,6EAA6E;IAC7E,+EAA+E;IAC/E,yBAAyB;IACzB,gBAAgB,EAAE,GAAG,EAAE,CAAC,IAAI;IAC5B,8EAA8E;IAC9E,+EAA+E;IAC/E,4EAA4E;IAC5E,6EAA6E;IAC7E,0CAA0C;CAC3C,CAAC"}
+{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../src/agents/cursor.ts"],"names":[],"mappings":"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"}

package/dist/agents/session_listing.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Listing a folder-keyed agent's sessions — `D11 · A`, `scan`.
+ *
+ * The two folder-keyed dialects (Claude Code, Cursor) differ in how a path is
+ * encoded and where a session sits under the folder, and agree on everything
+ * this file does: read directory ENTRIES, `lstat` a candidate for its time, and
+ * never open it.
+ *
+ * ⛔ **`lstat`, REGULAR FILES ONLY.** A symlink named `x.jsonl` is not a session
+ * (Cursor's gate resolves for exactly that reason), and a FIFO or socket under a
+ * root this client does not own is a thing a later `readFileSync` hangs on or
+ * throws on. A listing that only ever `lstat`s cannot be made to block, which is
+ * the property `scan` needs from the one command that walks the whole root.
+ */
+import { type Dirent } from "node:fs";
+import type { SourceSession } from "./types.js";
+/**
+ * The entries of a directory, `null` when it is simply not there, and a THROW
+ * for anything else (permissions, I/O) — the caller turns a throw into the
+ * agent's `unreadable` answer, so an absent store and a broken one stay apart.
+ */
+export declare function readEntries(dir: string): Dirent[] | null;
+/** One regular file's times, or null for anything that is not one. Never opens it. */
+export declare function sessionFile(path: string): SourceSession | null;
+/** `<dir>/<name>` for each entry that is a real directory (a symlink is not one). */
+export declare function subdirectories(dir: string): {
+    name: string;
+    path: string;
+}[];

package/dist/agents/session_listing.js

@@ -0,0 +1,49 @@
+/**
+ * Listing a folder-keyed agent's sessions — `D11 · A`, `scan`.
+ *
+ * The two folder-keyed dialects (Claude Code, Cursor) differ in how a path is
+ * encoded and where a session sits under the folder, and agree on everything
+ * this file does: read directory ENTRIES, `lstat` a candidate for its time, and
+ * never open it.
+ *
+ * ⛔ **`lstat`, REGULAR FILES ONLY.** A symlink named `x.jsonl` is not a session
+ * (Cursor's gate resolves for exactly that reason), and a FIFO or socket under a
+ * root this client does not own is a thing a later `readFileSync` hangs on or
+ * throws on. A listing that only ever `lstat`s cannot be made to block, which is
+ * the property `scan` needs from the one command that walks the whole root.
+ */
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The entries of a directory, `null` when it is simply not there, and a THROW
+ * for anything else (permissions, I/O) — the caller turns a throw into the
+ * agent's `unreadable` answer, so an absent store and a broken one stay apart.
+ */
+export function readEntries(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        throw err;
+    }
+}
+/** One regular file's times, or null for anything that is not one. Never opens it. */
+export function sessionFile(path) {
+    try {
+        const stat = lstatSync(path);
+        return stat.isFile() ? { path, mtimeMs: stat.mtimeMs } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** `<dir>/<name>` for each entry that is a real directory (a symlink is not one). */
+export function subdirectories(dir) {
+    return (readEntries(dir) ?? [])
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({ name: entry.name, path: join(dir, entry.name) }));
+}
+//# sourceMappingURL=session_listing.js.map

package/dist/agents/session_listing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session_listing.js","sourceRoot":"","sources":["../../src/agents/session_listing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAe,MAAM,SAAS,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,IAAI,CAAC;QACH,OAAO,WAAW,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,GAAI,GAA6B,CAAC,IAAI,CAAC;QACjD,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACzD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAChE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;SAC5B,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;SACtC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AACzE,CAAC"}

package/dist/agents/types.d.ts

@@ -137,13 +137,27 @@ export type RedactionProfile = "claude-code" | "codex-cli" | "cursor";
  */
 export type DelegatedTranscripts = "discover" | "announce";
 /**
- * The three hook events DESIGN.md §13.7 names.
+ * The four hook events this client registers.
  *
- * Both members of this lane fire the same three; that is exactly why
+ * Every member of this lane fires the same four; that is exactly why
  * `hook_event_name` was REJECTED as an adapter selector (`CR-183`) — the events
  * are shared, so they discriminate nothing.
+ *
+ * ⛔ **`SessionStart` is the fourth, and it is the one that never uploads** (0.7.0,
+ * eng review D3 · A). `Stop`, `PreCompact` and `SessionEnd` flow into the code
+ * that reads a transcript and sends it; `SessionStart` must only install git
+ * hooks and say so, so `hooks/entry.ts` resolves the canonical event FIRST and
+ * branches to its own handler before the consent gate and before anything reads
+ * `transcript_path`. It sits in this list, and not in a table of its own, so the
+ * compiler makes each dialect declare its budget and its spelling.
+ *
+ *   event          Claude Code    Codex          Cursor          reads a transcript
+ *   Stop           Stop           Stop           stop            yes
+ *   PreCompact     PreCompact     PreCompact     preCompact      yes
+ *   SessionEnd     SessionEnd     SessionEnd     sessionEnd      yes
+ *   SessionStart   SessionStart   SessionStart   sessionStart    NEVER
  */
-export declare const HOOK_EVENTS: readonly ["Stop", "PreCompact", "SessionEnd"];
+export declare const HOOK_EVENTS: readonly ["Stop", "PreCompact", "SessionEnd", "SessionStart"];
 export type HookEventName = (typeof HOOK_EVENTS)[number];
 /**
  * One event's two clocks, and the relation between them is the point.
@@ -173,6 +187,77 @@ export interface AgentHookConfig {
     readonly path: (home: string, env: NodeJS.ProcessEnv) => string;
     readonly shape: HookDocShape;
 }
+/**
+ * One transcript file a source adapter saw — `D11 · A`, `scan`.
+ *
+ * ⛔ **`stat`ed for its times and NEVER OPENED.** Everything the picker, the
+ * offer and the backfill count comes from names and times, because opening a
+ * transcript of a repo nobody granted is the read the consent design forbids. A
+ * field that could only be filled by reading the file does not belong here.
+ */
+export interface SourceSession {
+    readonly path: string;
+    readonly mtimeMs: number;
+    /**
+     * When the agent itself says the session began, where it keeps that. Codex's
+     * index does (`created_at`); the folder-keyed agents do not, and for them the
+     * file's mtime stands in everywhere a date is shown.
+     */
+    readonly startedMs?: number;
+}
+/** One agent project folder: its encoded name, and the sessions found in it. */
+export interface SourceFolder {
+    readonly name: string;
+    readonly sessions: readonly SourceSession[];
+}
+/** One index row: a session whose agent already recorded the folder it ran in. */
+export interface SourceRow {
+    readonly cwd: string;
+    readonly origin: string | null;
+    readonly session: SourceSession;
+}
+/** Why a store could not be listed. Each is a different line in `Not listed here`. */
+export type UnreadableReason = "unrecognised index" | "index locked" | "unreadable";
+/**
+ * What one agent's store yields, without a transcript being opened.
+ *
+ * The two shapes are the two ways the three agents keep sessions, and they are
+ * not interchangeable: a FOLDER-keyed agent (Claude Code, Cursor) names the
+ * folder by lossy encoding, so the engine has to resolve it against the
+ * filesystem and can fail to (`encode` and `isHashed` are what that walk needs);
+ * an INDEXED agent (Codex) records the real `cwd`, so it is never ambiguous.
+ *
+ * ⛔ **`unreadable` is an answer, not an exception.** One agent's store failing
+ * hides that agent's rows and nothing else's, and `scan` reports it; a thrown
+ * error here would take the other two agents' rows down with it.
+ */
+export type SessionSource = {
+    readonly kind: "folders";
+    readonly folders: readonly SourceFolder[];
+    /** This dialect's `encodeProjectPath`, handed over so the walk uses the same one. */
+    readonly encode: (path: string) => string;
+    /** Is this folder name a truncated-and-hashed one, which cannot be inverted? */
+    readonly isHashed: (name: string) => boolean;
+    /**
+     * Paths the agent ITSELF recorded having run in — a second skip signal. A
+     * folder whose name encodes to a recorded path that no longer exists is one
+     * whose sessions may belong to that deleted path, whatever else now matches.
+     * Empty for an agent that keeps no such record.
+     */
+    readonly recorded: readonly string[];
+} | {
+    readonly kind: "rows";
+    readonly rows: readonly SourceRow[];
+    /**
+     * Rollout files on disk that no index row names — counted, never opened. Only
+     * the index's own agent has the notion; a folder-keyed agent has no index to
+     * be missing from.
+     */
+    readonly unindexed: number;
+} | {
+    readonly kind: "unreadable";
+    readonly reason: UnreadableReason;
+};
 /** Where `connect` found the session running right now. */
 export interface LocatedTranscript {
     readonly path: string;
@@ -260,11 +345,14 @@ export interface TranscriptDialect {
      * (lost permanently — that event has no next invocation) and no gap-stamp
      * reserve. Nothing raises and the hook still exits 0.
      *
-     * ⚠ **Widening `HookEventName` was the obvious fix and it is the wrong one.**
-     * The three map 1:1, so a rename belongs in a per-dialect table; widening the
-     * union would make `Readonly<Record<HookEventName, EventBudget>>` non-total
-     * over the real event set and force every dialect to declare budgets for
-     * events it can never receive.
+     * ⚠ **Widening `HookEventName` was the wrong fix for a RENAME, and it is the right
+     * one for a new event** (0.7.0, eng review D3 · A). The first three map 1:1, so a
+     * rename belongs in a per-dialect table. `SessionStart` is a new event that ALL
+     * THREE agents deliver (Claude Code and Codex measured live, Cursor read out of
+     * the shipped bundle — see each dialect), so the argument that stopped the
+     * widening — "force every dialect to declare budgets for events it can never
+     * receive" — no longer holds, and the compiler is now the thing that makes a
+     * dialect added later declare its `SessionStart` spelling and budget.
      *
      * ## ⚠ MEASURED per dialect, and the two measurements differ in kind
      *
@@ -304,6 +392,28 @@ export interface TranscriptDialect {
      * is exactly the cap Codex silently clamps to — measured, not inferred.
      */
     readonly hookConfig: AgentHookConfig;
+    /**
+     * ⛔ **WHAT SESSIONS DOES THIS AGENT HAVE ON DISK — without opening one.**
+     * `D11 · A`, `scan`, the picker and the backfill offer.
+     *
+     * Listed by NAME and TIME only (`SourceSession`). The consent design is that no
+     * path opens a transcript of an ungranted repo, so the thing that decides what
+     * to offer cannot be the thing that reads the transcripts. ⚠ Each adapter fails
+     * closed on its own: an unreadable store is `{ kind: "unreadable" }` and hides
+     * that agent's rows only.
+     *
+     * ⛔ **REQUIRED, not optional, and that is `admitsFile`'s device.** A dialect
+     * added later must ANSWER how its sessions are found, and the compiler is what
+     * asks; an agent that cannot answer without opening a transcript returns
+     * `unreadable` and says so, which is a decision a reviewer sees.
+     *
+     * ⚠ A MEASURED requirement and not a speculative one: Open Question 3 found the
+     * two folder-keyed agents encode a path DIFFERENTLY (Claude Code per UTF-16
+     * unit with no collapsing; Cursor collapsing runs and trimming the ends), and
+     * the shipped `connect` looked in the wrong folder for any repo path holding an
+     * `_` or a space because it assumed one rule.
+     */
+    readonly sessionSource: (home: string, env: NodeJS.ProcessEnv) => SessionSource;
     /** Per-event clocks. See `EventBudget` for the relation that binds them. */
     readonly events: Readonly<Record<HookEventName, EventBudget>>;
     readonly delegatedTranscripts: DelegatedTranscripts;

package/dist/agents/types.js

@@ -57,11 +57,25 @@
  */
 export const UNKNOWN_AGENT_ID = "unknown";
 /**
- * The three hook events DESIGN.md §13.7 names.
+ * The four hook events this client registers.
  *
- * Both members of this lane fire the same three; that is exactly why
+ * Every member of this lane fires the same four; that is exactly why
  * `hook_event_name` was REJECTED as an adapter selector (`CR-183`) — the events
  * are shared, so they discriminate nothing.
+ *
+ * ⛔ **`SessionStart` is the fourth, and it is the one that never uploads** (0.7.0,
+ * eng review D3 · A). `Stop`, `PreCompact` and `SessionEnd` flow into the code
+ * that reads a transcript and sends it; `SessionStart` must only install git
+ * hooks and say so, so `hooks/entry.ts` resolves the canonical event FIRST and
+ * branches to its own handler before the consent gate and before anything reads
+ * `transcript_path`. It sits in this list, and not in a table of its own, so the
+ * compiler makes each dialect declare its budget and its spelling.
+ *
+ *   event          Claude Code    Codex          Cursor          reads a transcript
+ *   Stop           Stop           Stop           stop            yes
+ *   PreCompact     PreCompact     PreCompact     preCompact      yes
+ *   SessionEnd     SessionEnd     SessionEnd     sessionEnd      yes
+ *   SessionStart   SessionStart   SessionStart   sessionStart    NEVER
  */
-export const HOOK_EVENTS = ["Stop", "PreCompact", "SessionEnd"];
+export const HOOK_EVENTS = ["Stop", "PreCompact", "SessionEnd", "SessionStart"];
 //# sourceMappingURL=types.js.map

package/dist/agents/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AA4BH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AA6D1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,YAAY,CAAU,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/agents/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AA4BH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AA6D1C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,CAAU,CAAC"}

package/dist/commands/approval_pending.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The org-approval-pending block — style guide §10.2's "held" beat, D65 §DR6, D81. One definition for the two places that
+ * print it: `connect`, on the 403 its own test capture got, and `status`, for a repo whose last upload got that same 403.
+ *
+ * ⚠ EXISTING COPY ONLY. `status` adds no sentence of its own; it prints what `connect` prints, so the two cannot drift
+ * (`org_pending.ts` records that the 403 happened). The shared clause renders on EVERY branch and `owners_notified` `> 0`
+ * ADDS to it (D81); `null` and `0` never claim a notification.
+ */
+export declare function approvalPendingBlock(colour: boolean, repoSlug: string, ownersNotified: number | null): string[];

package/dist/commands/approval_pending.js

@@ -0,0 +1,23 @@
+/**
+ * The org-approval-pending block — style guide §10.2's "held" beat, D65 §DR6, D81. One definition for the two places that
+ * print it: `connect`, on the 403 its own test capture got, and `status`, for a repo whose last upload got that same 403.
+ *
+ * ⚠ EXISTING COPY ONLY. `status` adds no sentence of its own; it prints what `connect` prints, so the two cannot drift
+ * (`org_pending.ts` records that the 403 happened). The shared clause renders on EVERY branch and `owners_notified` `> 0`
+ * ADDS to it (D81); `null` and `0` never claim a notification.
+ */
+import { CONNECT, URLS } from "../copy/index.js";
+import { renderErrorBlock } from "../term.js";
+export function approvalPendingBlock(colour, repoSlug, ownersNotified) {
+    const why = ownersNotified !== null && ownersNotified > 0
+        ? `${CONNECT.pendingRecorded} ${CONNECT.pendingNotified(ownersNotified)}`
+        : CONNECT.pendingRecorded;
+    return renderErrorBlock({
+        kind: "warn",
+        what: CONNECT.pendingWhat,
+        why: [CONNECT.pendingWhy(repoSlug), why, CONNECT.pendingBuffered],
+        fixLabel: CONNECT.pendingTrackLabel,
+        fixes: [URLS.captureAccess],
+    }, colour);
+}
+//# sourceMappingURL=approval_pending.js.map

package/dist/commands/approval_pending.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval_pending.js","sourceRoot":"","sources":["../../src/commands/approval_pending.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,UAAU,oBAAoB,CAAC,MAAe,EAAE,QAAgB,EAAE,cAA6B;IACnG,MAAM,GAAG,GACP,cAAc,KAAK,IAAI,IAAI,cAAc,GAAG,CAAC;QAC3C,CAAC,CAAC,GAAG,OAAO,CAAC,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE;QACzE,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;IAC9B,OAAO,gBAAgB,CACrB;QACE,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,OAAO,CAAC,WAAW;QACzB,GAAG,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,eAAe,CAAC;QACjE,QAAQ,EAAE,OAAO,CAAC,iBAAiB;QACnC,KAAK,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;KAC5B,EACD,MAAM,CACP,CAAC;AACJ,CAAC"}

package/dist/commands/auth.d.ts

@@ -75,6 +75,7 @@
  */
 import type { CommandContext } from "./context.js";
 import type { BrowserCredential, BrowserOptions, Retry } from "./browser_credential.js";
+import type { VerbSyncDeps } from "../grants_verb.js";
 export interface AuthDeps {
     /**
      * Read the secret from a terminal WITHOUT ECHOING IT. Injected for the same
@@ -101,5 +102,11 @@ export interface AuthDeps {
      * `src/index.ts` passes one that carries NO `browser` (never a second sign-in).
      */
     readonly connect?: (ctx: CommandContext) => Promise<number>;
+    /**
+     * Slice 2, R3-7. The account's network, injected like `connect`: a credential this verb saves on a machine that has synced before
+     * is synced before the verb returns, so the new credential row is synced from its first upload. Left out, the verb makes no
+     * request, as before. `src/index.ts` passes the real `fetch`.
+     */
+    readonly account?: VerbSyncDeps;
 }
 export declare function auth(ctx: CommandContext, argv: readonly string[], deps?: AuthDeps): Promise<number>;

package/dist/commands/auth.js

@@ -73,11 +73,14 @@
  * @provenance vibecommit-mcp src/transport/server.ts — POST /oauth/ingest-credential is the mint route, verified
  * @provenance vibecommit-web app/api/ingest-credentials/route.ts — the dashboard producer the paste path still serves, verified
  */
-import { AUTH, COMMANDS, DEVICE, HELP, URLS } from "../copy/index.js";
-import { authCommandFor } from "../install.js";
+import { AUTH, DEVICE, PICKER, URLS } from "../copy/index.js";
+import { renderVerbHelp } from "../verb_help.js";
+import { authCommandFor, channelCommand } from "../install.js";
 import { writeLines } from "./context.js";
 import { EXIT } from "../exit.js";
 import { INGEST_TOKEN_PREFIX, IngestCredential, saveCredential } from "../credential.js";
+import { readGrants } from "../consent.js";
+import { machineCapture, machineSummary } from "../machine_state.js";
 import { credentialsPath } from "../paths.js";
 import { resolveProjectKeys } from "../project.js";
 import { paint, renderErrorBlock, tildePath, wrap } from "../term.js";
@@ -98,10 +101,11 @@ export async function auth(ctx, argv, deps = {}) {
     if (positional.length > 0) {
         writeLines(ctx.stderr, renderErrorBlock({
             kind: "bad",
+            code: "CREDENTIAL_IN_ARGV",
             what: AUTH.argvWhat,
             why: [AUTH.argvWhy],
             fixLabel: AUTH.argvFix,
-            fixes: [AUTH.argvFixPrompt, AUTH.argvFixStdin],
+            fixes: [channelCommand(ctx.env, ctx.selfPath, AUTH.argvFixPrompt), AUTH.argvFixStdin(authCommandFor(ctx.env, ctx.selfPath))],
         }, ctx.colour));
         return EXIT.usage;
     }
@@ -110,7 +114,8 @@ export async function auth(ctx, argv, deps = {}) {
     // exactly that a usage error) runs first. By the time this is reached, `positional.length === 0`, so
     // `--help` still has no side effects — nothing below has read or written anything yet either way.
     if (argv.includes("--help") || argv.includes("-h")) {
-        writeLines(ctx.stdout, [HELP.commands.auth]);
+        const helpVerb = "auth"; // an identifier, not a literal, at the writer: `copy-inline-literals` follows argument positions
+        writeLines(ctx.stdout, renderVerbHelp(helpVerb));
         return EXIT.ok;
     }
     const piped = argv.includes(STDIN_FLAG) || !ctx.stdinIsTty;
@@ -119,6 +124,7 @@ export async function auth(ctx, argv, deps = {}) {
         writeLines(ctx.stderr, renderErrorBlock(piped
             ? {
                 kind: "bad",
+                code: "SIGNIN_CODE_NEEDS_TTY",
                 what: DEVICE.needsTerminalWhat,
                 why: [DEVICE.needsTerminalWhy],
                 fixLabel: DEVICE.needsTerminalFix,
@@ -126,10 +132,11 @@ export async function auth(ctx, argv, deps = {}) {
             }
             : {
                 kind: "bad",
+                code: "AUTH_FLAGS_CONFLICT",
                 what: DEVICE.conflictWhat,
                 why: [DEVICE.conflictWhy],
                 fixLabel: DEVICE.conflictFix,
-                fixes: [COMMANDS.auth, `${COMMANDS.auth} ${PASTE_FLAG}`],
+                fixes: [authCommandFor(ctx.env, ctx.selfPath), `${authCommandFor(ctx.env, ctx.selfPath)} ${PASTE_FLAG}`],
             }, ctx.colour));
         return EXIT.usage;
     }
@@ -161,10 +168,11 @@ export async function auth(ctx, argv, deps = {}) {
     if (secret === "") {
         writeLines(ctx.stderr, renderErrorBlock({
             kind: "bad",
+            code: "CREDENTIAL_EMPTY",
             what: AUTH.emptyWhat,
             why: [AUTH.emptyWhy],
-            fixLabel: AUTH.emptyFix,
-            fixes: [URLS.settings],
+            fixLabel: AUTH.mintFix(URLS.settings),
+            fixes: AUTH.mintCommands(authCommandFor(ctx.env, ctx.selfPath)),
         }, ctx.colour));
         return EXIT.failure;
     }
@@ -175,10 +183,11 @@ export async function auth(ctx, argv, deps = {}) {
     if (!secret.startsWith(INGEST_TOKEN_PREFIX)) {
         writeLines(ctx.stderr, renderErrorBlock({
             kind: "bad",
+            code: "CREDENTIAL_NOT_INGEST",
             what: AUTH.wrongClassWhat,
             why: [AUTH.wrongClassWhy],
-            fixLabel: AUTH.wrongClassFix,
-            fixes: [URLS.settings],
+            fixLabel: AUTH.mintFix(URLS.settings),
+            fixes: AUTH.mintCommands(authCommandFor(ctx.env, ctx.selfPath)),
         }, ctx.colour));
         return EXIT.failure;
     }
@@ -194,17 +203,49 @@ export async function auth(ctx, argv, deps = {}) {
  * block and the exit are exactly what they were.
  */
 async function saved(ctx, deps, piped, notes = []) {
-    const shouldConnect = !piped && deps.connect !== undefined && resolveProjectKeys(ctx.cwd) !== null;
+    // 0.7.0, D32 · 26A (supersedes only L6's "outside a repository" clause). Inside a work tree the chain is unchanged (L2).
+    // Outside one, the continuation is the picker flow, and only on a machine that has nothing captured yet; a machine that
+    // already captures prints one line and no picker. ⛔ BOTH of 0.6.0's other guards stay: `piped` (`--stdin`, or no
+    // terminal) NEVER continues, so a CI runner with no grant still saves the credential and exits 0 instead of reaching the
+    // non-terminal refusal and exiting 2; and the continuation gets no `browser` (`index.ts` hands `connect` none), so a
+    // second sign-in cannot start.
+    const inRepo = resolveProjectKeys(ctx.cwd) !== null;
+    const capture = inRepo || piped || deps.connect === undefined ? null : machineCapture(ctx.home);
+    const shouldConnect = !piped && deps.connect !== undefined && (inRepo || capture?.kind === "none");
+    const staysOn = capture?.kind === "on";
     writeLines(ctx.stdout, [
         ...renderErrorBlock({
             kind: "ok",
             what: AUTH.savedWhat,
             why: [AUTH.savedWhy(tildePath(credentialsPath(ctx.home), ctx.home)), ...notes],
-            ...(shouldConnect ? {} : { fixLabel: AUTH.nextLabel, fixes: [AUTH.nextCommand] }),
+            ...(shouldConnect || staysOn
+                ? {}
+                : { fixLabel: AUTH.nextLabel, fixes: [channelCommand(ctx.env, ctx.selfPath, AUTH.nextCommand)] }),
         }, ctx.colour),
+        ...(capture?.kind === "on" ? ["", ...wrap(PICKER.authStays(machineSummary(capture)), 2)] : []),
     ]);
     if (shouldConnect && deps.connect !== undefined)
         return await deps.connect(ctx);
+    // Not chaining (the chained `connect` syncs for itself): this is the only other place a credential is saved, so it is the other
+    // place a new credential row is synced. ⛔ It makes no prompt and prints nothing, so a piped or no-terminal `auth` (which never
+    // continues, D32 guard 1) is as quiet as before; a failure is silent and the exit stays what it was.
+    // ⛔ A piped, `--stdin` or no-terminal `auth` does NOT sync (L10: "with `--stdin`, or with no terminal, it only saves the credential"): a
+    // sync sends this machine's grants, which is more than saving. R3-7 is for a person at a terminal.
+    if (!piped)
+        await syncNewCredential(ctx, deps);
     return EXIT.ok;
 }
+/**
+ * R3-7, for a TERMINAL `auth` only (the caller skips a piped one). Only a machine that HAS synced (`grants.json`'s `synced_at`) syncs here: a machine that never has would be making a FIRST
+ * sync, which prints what it is saving and belongs to `connect`/`status`/`off`, not to a verb whose job is to save a credential.
+ * Bounded at 3 s and silent on failure (`syncForVerb` never throws).
+ */
+async function syncNewCredential(ctx, deps) {
+    if (deps.account === undefined)
+        return;
+    const read = readGrants(ctx.home);
+    if (read.kind !== "ok" || read.grants.synced_at === null)
+        return;
+    await (await import("../grants_verb.js")).syncForVerb(ctx, false, deps.account);
+}
 //# sourceMappingURL=auth.js.map