@blastin-dev/clocktopus-cli 0.2.1 → 0.3.1

package/README.md

@@ -149,8 +149,8 @@ things decide whether they mean anything, and neither is visible locally:
 | Repository attached to a project | Spend is recorded, but lands in the unattributed row instead of against a client |
 | Push webhook delivering          | No human time entries, so there is nothing to compare the spend against          |
 
-The second does **not** stop agent→commit links — the SessionEnd hook
-resolves `git rev-list before..after` locally and posts the list, so those
+The second does **not** stop agent→commit links — the SessionEnd hook reads
+your checkout's own reflog locally and posts the commits it authored, so those
 are created with no webhook involved. What is missing is the other side of
 the comparison: true cost is human time × rate _plus_ agent spend, and one
 term alone is not a smaller answer.

package/dist/src/commands/agent/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/doctor.ts"],"names":[],"mappings":"AAuCA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA8CnD"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/doctor.ts"],"names":[],"mappings":"AAmCA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA6CnD"}

package/dist/src/commands/agent/doctor.js

@@ -36,9 +36,8 @@ export async function doctorCommand() {
             checks: await agentChecks(entry),
         });
     }
-    // Past this point the pipeline works; these decide whether what it carries
-    // can be turned into a number. Both are server-side facts about the
-    // repository, not about any one agent.
+    // Past this point the pipeline works; these decide whether what it carries can be turned
+    // into a number. Both are server-side facts about the repository, not about any one agent.
     const tail = [];
     const repoStatus = await fetchRepoStatus();
     if (repoStatus)
@@ -91,10 +90,9 @@ async function agentChecks(entry) {
             : `not configured in ${state.paths.join(", ")}`,
         fix: `clocktopus agent setup --agent ${entry.agent.id}`,
     });
-    // Both events are required, and for different reasons: SessionStart is the
-    // only source of the *before* SHA and of `cwd`, SessionEnd is the only
-    // source of the exact commit list. One without the other silently
-    // degrades what can be attributed.
+    // Both events are required, for different reasons: SessionStart is the only source of the
+    // *before* SHA and of `cwd`, SessionEnd the only source of the exact commit list. One
+    // without the other silently degrades what can be attributed.
     const hookStart = state.hookCommands.SessionStart;
     const hookEnd = state.hookCommands.SessionEnd;
     checks.push({
@@ -109,10 +107,9 @@ async function agentChecks(entry) {
     });
     if (hookStart)
         checks.push(checkHookRuns(hookStart));
-    // A warning, not a failure: a plugin from an older generation still
-    // reports. What it does not have is whatever the newer one fixed, and
-    // nothing else in this report would ever say so — the token is valid, the
-    // hook resolves, the receiver answers.
+    // A warning, not a failure: a plugin from an older generation still reports. What it does
+    // not have is whatever the newer one fixed, and nothing else in this report would say so
+    // — the token is valid, the hook resolves, the receiver answers.
     const stale = entry.agent.staleReason?.() ?? null;
     if (stale) {
         checks.push({
@@ -158,23 +155,20 @@ async function agentChecks(entry) {
                 : "clocktopus agent setup --force  (mints a replacement token)",
         });
     }
-    // Only Claude Code applies config `env` over the inherited environment,
-    // so only it can be shadowed by a shell export.
+    // Only Claude Code applies config `env` over the inherited environment, so only it can be
+    // shadowed by a shell export.
     if (entry.agent.id === "claude")
         checks.push(checkShadowedExports());
     checks.push(checkRestartNeeded(entry, state.modifiedAt));
     return checks;
 }
-/**
- * Runs the installed hook command with empty stdin.
- *
- * This is a genuine no-op — the hook returns immediately when stdin carries
- * no payload — so it sends nothing and records nothing, while still proving
- * the exact command line in the agent's config resolves and executes. Worth
- * checking directly: hooks run under a shell whose PATH may differ from the
- * interactive one, and a command that fails to resolve there fails
- * silently, costing every session its repository context.
- */
+// Runs the installed hook command with empty stdin.
+//
+// A genuine no-op — the hook returns immediately when stdin carries no payload — so it
+// sends and records nothing while still proving the exact command line in the agent's
+// config resolves and executes. Worth checking directly: hooks run under a shell whose
+// PATH may differ from the interactive one, and a command that fails to resolve there
+// fails silently, costing every session its repository context.
 function checkHookRuns(command) {
     try {
         execSync(command, {
@@ -217,18 +211,15 @@ function checkShadowedExports() {
             "      disagree is how spend lands on the wrong account.",
     };
 }
-/**
- * Did the configuration change after the last session used it?
- *
- * The exporter and the hook both read their configuration once, at process
- * start, so a session already open when setup ran is still using the old
- * values. This is the most common reason a correct configuration looks dead.
- *
- * Scoped to the agent whose hook last ran: one receipt file is shared by all
- * of them, and comparing Claude Code's last run against Codex's config
- * mtime would report a restart that has already happened, or miss one that
- * has not.
- */
+// Did the configuration change after the last session used it?
+//
+// The exporter and the hook both read their configuration once, at process start, so a
+// session already open when setup ran is still using the old values. This is the most
+// common reason a correct configuration looks dead.
+//
+// Scoped to the agent whose hook last ran: one receipt file is shared by all of them, and
+// comparing Claude Code's last run against Codex's config mtime would report a restart
+// that has already happened, or miss one that has not.
 function checkRestartNeeded(entry, configModifiedAt) {
     const lastRun = readLastRun();
     const ranThisAgent = lastRun?.provider === entry.agent.provider;

package/dist/src/commands/agent/hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/hook.ts"],"names":[],"mappings":"AAwaA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB"}
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/hook.ts"],"names":[],"mappings":"AAmcA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhB"}

package/dist/src/commands/agent/hook.js

@@ -3,71 +3,85 @@ import { resolve as resolvePath } from "node:path";
 import { maskToken, resolveAgentCredentials } from "../../lib/agent-config.js";
 import { clearStartState, listStartStates, readStartState, recordLastRun, writeStartState, } from "../../lib/agent-hook-state.js";
 import { AGENTS } from "../../lib/agents.js";
-/**
- * SessionStart / SessionEnd hook → Clocktopus. Serves every agent.
- *
- * Claude Code and Codex both pipe their hook JSON to stdin, and — verified
- * against 2.1.234 and 0.147.0 — they pipe the *same* JSON: `session_id`,
- * `cwd`, `hook_event_name`, `source`, `reason`, same spellings. That is why
- * one subcommand handles both, and also why `--provider` exists: nothing in
- * the payload says which agent sent it, so the answer has to come from how
- * the hook was installed.
- *
- * That JSON is the only place `cwd` appears anywhere in the telemetry
- * pipeline — neither agent's telemetry export carries path, repository or
- * branch data — so without this hook every agent session is unattributable
- * and the ledger can only show totals.
- *
- * Previously a standalone script under `scripts/agent-telemetry/`, which
- * meant `settings.json` had to reference an absolute path inside a checkout
- * of this repository. Shipping it as a subcommand is what makes the feature
- * installable by anyone: the hook is wherever the CLI is.
- *
- * Contract with the host process, all three parts load-bearing: never write
- * to stdout (Claude Code parses it), never throw, always exit 0. Telemetry
- * must not be able to break the session it measures.
- *
- * ## Getting off the session's critical path
- *
- * This hook does network I/O — its own POST, plus a sweep of abandoned
- * sessions at SessionStart — and none of it may be charged to the developer
- * waiting for their session to start.
- *
- * Claude Code solves this for us: `"async": true` in `settings.json` makes
- * it background the hook. Codex does not, or not reliably — behaviour
- * verified by running both binaries:
- *
- * | `async: true` on | Codex 0.147                    | Codex 0.148          |
- * | ---------------- | ------------------------------ | -------------------- |
- * | SessionStart     | **skips the hook**, with a warning | honoured, no warning |
- * | SessionEnd       | runs it synchronously, with a warning | unchanged       |
- *
- * The 0.147 row is the dangerous one: a skipped SessionStart costs every
- * Codex session its `cwd`, and with it the repository, the branch and the
- * starting SHA — spend keeps arriving, attributed to nothing, with only a
- * startup warning to say so.
- *
- * Rather than sniff the version, the Codex hooks carry no `async` key at
- * all and this command backgrounds *itself*: it relays the payload to a
- * detached copy and returns in a few milliseconds. One mechanism, correct
- * on every version, and silent on all of them.
- *
- * SessionEnd needs it regardless of version. Codex still hard-clamps that
- * hook to 3s — shorter than this file's own 4s request timeout — so a slow
- * network would see the hook killed mid-POST and the session never closed.
- * The clamp only has to cover a spawn.
- */
+import { buildReflogArgs, parseReflogCommits, } from "../../lib/declared-commits.js";
+import { parseGitRemotes } from "../../lib/git-remotes.js";
+// SessionStart / SessionEnd hook → Clocktopus. Serves every agent.
+//
+// Claude Code and Codex both pipe the *same* hook JSON to stdin — `session_id`,
+// `cwd`, `hook_event_name`, `source`, `reason`, same spellings (verified against
+// 2.1.234 and 0.147.0). That is why one subcommand handles both, and why
+// `--provider` exists: nothing in the payload says which agent sent it.
+//
+// That JSON is the only place `cwd` appears anywhere in the pipeline, so without
+// this hook every agent session is unattributable and the ledger can only show
+// totals. Shipping it as a subcommand rather than a script under `scripts/` is what
+// makes the feature installable by anyone: the hook is wherever the CLI is.
+//
+// Contract with the host process, all three parts load-bearing: never write to
+// stdout (Claude Code parses it), never throw, always exit 0.
+//
+// Getting off the session's critical path: this hook does network I/O, and none of
+// it may be charged to the developer waiting for their session. Claude Code's
+// `"async": true` backgrounds it; Codex does not, or not reliably —
+//
+//   `async: true` on | Codex 0.147                | Codex 0.148
+//   SessionStart     | SKIPS the hook, with warning | honoured, no warning
+//   SessionEnd       | runs it synchronously        | unchanged
+//
+// The 0.147 row is the dangerous one: a skipped SessionStart costs every Codex
+// session its `cwd`, and with it the repository, branch and starting SHA. So rather
+// than sniff the version, the Codex hooks carry no `async` key and this command
+// backgrounds *itself*, relaying the payload to a detached copy. SessionEnd needs
+// that regardless: Codex hard-clamps it to 3s, shorter than this file's own 4s
+// request timeout, and the clamp only has to cover a spawn.
 const TIMEOUT_MS = 4000;
-/**
- * How long a state file must sit untouched before its session is presumed
- * dead. A file only survives SessionEnd if the session never got one —
- * SIGKILL, a crash, or the machine going down — but a long-running session
- * is perfectly normal, so this sits well past a working day rather than at
- * the point a session merely looks idle.
- */
+// How long a state file must sit untouched before its session is presumed dead. A
+// file survives SessionEnd only if the session never got one — SIGKILL, a crash, the
+// machine going down — but a long-running session is normal, so this sits well past
+// a working day rather than at the point one merely looks idle.
 const ABANDONED_AFTER_MS = 12 * 60 * 60 * 1000;
 /** Bound on one sweep, so a directory left full of state cannot stall a start. */
 const MAX_SWEEP_PER_RUN = 10;
+// The commits this checkout authored inside the session's window. Empty when the
+// session's start was never recorded, which is the deliberate answer — see
+// `buildReflogArgs`.
+function declaredCommits(cwd, startedAt, until) {
+    const args = buildReflogArgs({ startedAt, until });
+    if (!args)
+        return [];
+    return parseReflogCommits(git(cwd, args));
+}
+// What the *sweep* may declare, which is nothing at all for most hosts.
+//
+// The upper bound has to be the last moment this machine has evidence the session was
+// alive, and the only such record is the state file's mtime. That is real evidence
+// only where the host re-writes the file as the session goes — OpenCode, whose
+// SessionEnd repeats. Everywhere else the file is written once at SessionStart, so the
+// mtime *is* the start: the window collapses to `[startedAt, startedAt]` and can match
+// nothing the session wrote, only a commit made just before it began. Those would be
+// recorded as `declared`, which outranks the time window and is permanent.
+//
+// Dropping the bound instead is worse. The sweep runs up to twelve hours late, so an
+// unbounded read declares everything the developer committed in between.
+//
+// So: declare nothing, and leave these sessions to `linkCommitsByTimeWindow`, which
+// bounds itself with the server's telemetry-stamped end rather than a file's mtime.
+function sweptCommits(state, lastActivityAt) {
+    const host = AGENTS.find((agent) => agent.provider === state.provider);
+    if (!host?.hostRepeatsSessionEnd)
+        return [];
+    return declaredCommits(state.cwd, state.startedAt, lastActivityAt.toISOString());
+}
+/** Omits the field entirely when there is nothing to declare, rather than sending `[]`. */
+function declaredShasFor(shas) {
+    return shas.length > 0 ? { commit_shas: shas } : {};
+}
+// Shared by the live hook and the sweep so an abandoned session resolves its
+// repository the same way a live one does.
+function remotesFor(cwd) {
+    const remotes = parseGitRemotes(git(cwd, ["remote", "-v"]));
+    return { repository_url: remotes[0], repository_urls: remotes };
+}
 function git(cwd, args) {
     try {
         return execFileSync("git", args, {
@@ -97,8 +111,8 @@ async function post(endpoint, token, body) {
         return { status: response.status, error: null };
     }
     catch (error) {
-        // Telemetry must never break the session it measures. The failure is
-        // recorded for `agent doctor` instead of surfaced here.
+        // Telemetry must never break the session it measures. The failure is recorded for
+        // `agent doctor` instead of surfaced here.
         return {
             status: null,
             error: error instanceof Error ? error.message : "request failed",
@@ -108,26 +122,19 @@ async function post(endpoint, token, body) {
         clearTimeout(timer);
     }
 }
-/**
- * Closes sessions that were never given a SessionEnd.
- *
- * A state file outlives its session only when the process died without
- * running the hook, and until something closes it the session keeps a null
- * `ended_at` and a null `git_head_after` forever.
- *
- * It deliberately does **not** send `commit_shas`. The honest range for a
- * dead session is unknowable after the fact: `before..HEAD` also contains
- * everything committed in the hours since it died, and the receiver records
- * hook-supplied commits as `declared`, which outranks a `time_window` link
- * and would make a bad guess permanent. Closing the session is enough —
- * with a real `ended_at` the webhook's time-window pass can then link its
- * commits from the commit timestamps, which are bounded by data rather than
- * by assumption.
- *
- * For the same reason it sends its own `ended_at` rather than letting the
- * receiver stamp one: this runs when the *next* session starts, potentially
- * a day later.
- */
+// Closes sessions that were never given a SessionEnd, which otherwise keep a null
+// `ended_at` and `git_head_after` forever.
+//
+// It now declares commits too, which a range could never let it do. `before..HEAD`
+// resolved after the fact also contains everything committed in the hours since, and
+// a hook-supplied commit is recorded as `declared`, which outranks a `time_window`
+// link — a bad guess would be permanent. The reflog is bounded by data instead: it is
+// on disk, it is stamped, and the session's own window brackets it. That closes the
+// case this whole area exists for, an agent left running unattended and killed before
+// it could report anything.
+//
+// It sends its own `ended_at` for a related reason: this runs when the *next* session
+// starts, potentially a day later.
 async function sweepAbandonedSessions(endpoint, token, currentSessionId, fallbackProvider) {
     let swept = 0;
     for (const { sessionId, ageMs, lastActivityAt } of listStartStates()) {
@@ -139,15 +146,15 @@ async function sweepAbandonedSessions(endpoint, token, currentSessionId, fallbac
             continue;
         swept++;
         const state = readStartState(sessionId);
-        // Nothing recoverable without the originating checkout — drop the file
-        // rather than resolve its SHA against an unrelated repository.
+        // Nothing recoverable without the originating checkout — drop the file rather than
+        // resolve its SHA against an unrelated repository.
         if (!state?.cwd) {
             clearStartState(sessionId);
             continue;
         }
-        // Kept alive only so a repeating SessionEnd could still diff against it.
-        // The session already ended properly; sweeping it would replace a real
-        // end with this moment's HEAD. Just collect the file.
+        // Kept alive only so a repeating SessionEnd could still diff against it. The session
+        // already ended properly; sweeping it would replace a real end with this moment's
+        // HEAD.
         if (state.closed) {
             clearStartState(sessionId);
             continue;
@@ -155,56 +162,58 @@ async function sweepAbandonedSessions(endpoint, token, currentSessionId, fallbac
         const head = git(state.cwd, ["rev-parse", "HEAD"]);
         if (head) {
             await post(endpoint, token, {
-                // The agent that *opened* the session, not the one sweeping it.
-                // Closing a Codex session as `claude_code` would leave the real row
-                // hanging and create an empty duplicate under the wrong provider.
+                // The agent that *opened* the session, not the one sweeping it. Closing a Codex
+                // session as `claude_code` would leave the real row hanging and create an empty
+                // duplicate under the wrong provider.
                 provider: readProvider(state.provider) ?? fallbackProvider,
                 session_id: sessionId,
                 hook_event_name: "SessionEnd",
                 cwd: state.cwd,
                 reason: "abandoned",
-                // Never "now": this session died hours ago, and the receiver would
-                // otherwise record a window spanning everything since. The receiver
-                // treats this as a fallback and keeps a telemetry-stamped end if it
-                // has one; this value only fills the gap when it has none.
+                // Never "now": this session died hours ago. The receiver treats this as a fallback
+                // and keeps a telemetry-stamped end if it has one.
                 ended_at: lastActivityAt.toISOString(),
-                repository_url: git(state.cwd, ["remote", "get-url", "origin"]),
-                git_branch: git(state.cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
+                // A remote is a property of the checkout and does not drift; the branch is a
+                // property of the moment, and this moment is hours after the session died.
+                // Sending one would overwrite the branch SessionStart recorded — `COALESCE` lets
+                // any non-null value win — replacing real evidence with wherever the developer
+                // happens to be now. Omitted so the recorded branch survives.
+                ...remotesFor(state.cwd),
+                ...declaredShasFor(
+                // Spread rather than passed whole so the `state.cwd` guard above narrows.
+                sweptCommits({
+                    cwd: state.cwd,
+                    provider: state.provider,
+                    startedAt: state.startedAt,
+                }, lastActivityAt)),
                 git_head_before: state.sha,
+                // Same objection as the branch, kept only because nothing reads it: it is
+                // diagnostic, and removing it would change what `agent doctor` shows for no gain.
                 git_head_after: head,
             });
         }
         clearStartState(sessionId);
     }
 }
-/**
- * Reads a provider back off a state file written by an older CLI.
- *
- * Those files have no `provider` at all, and the only agent that could have
- * written one was Claude Code — so `undefined` is not a missing value here,
- * it is `claude_code`. That is the caller's fallback, applied by returning
- * null rather than guessing here.
- */
+// Reads a provider back off a state file written by an older CLI. Those files have
+// no `provider`, and the only agent that could have written one was Claude Code — so
+// `undefined` is not a missing value, it is `claude_code`. Returning null lets the
+// caller apply that fallback rather than guessing here.
 function readProvider(value) {
     const match = AGENTS.find((agent) => agent.provider === value);
     return match?.provider ?? null;
 }
-/**
- * Re-runs this command in a detached copy and hands it the payload.
- *
- * `detached: true` is what makes it survive: it puts the child in its own
- * process group, so the host tearing down the session's group at exit —
- * which is exactly when SessionEnd fires — cannot take the POST with it.
- *
- * Waiting for `stdin.end` to flush is not optional. The parent returns
- * immediately afterwards, and an unflushed write would die with it; a hook
- * payload is well under the pipe buffer, so this resolves without waiting
- * for the child to read anything.
- *
- * Returns false if the spawn could not be arranged at all, in which case
- * the caller does the work inline — a slow session start is worth more than
- * a lost one.
- */
+// Re-runs this command in a detached copy and hands it the payload.
+//
+// `detached: true` puts the child in its own process group, so the host tearing down
+// the session's group at exit — exactly when SessionEnd fires — cannot take the POST
+// with it.
+//
+// Waiting for `stdin.end` to flush is not optional: the parent returns immediately
+// afterwards and an unflushed write would die with it. A hook payload is well under
+// the pipe buffer, so this resolves without waiting for the child to read.
+//
+// False if the spawn could not be arranged, in which case the caller works inline.
 function detachSelf(provider, payload) {
     const script = process.argv[1] ? resolvePath(process.argv[1]) : null;
     if (!script)
@@ -231,21 +240,21 @@ async function readStdin() {
 async function run(agent, detached) {
     const { token, endpoint } = resolveAgentCredentials(agent.id);
     if (!token || !endpoint) {
-        // Not configured. Silence is correct: agent telemetry is opt-in, and a
-        // machine that never ran `clocktopus agent setup` should notice nothing.
+        // Not configured. Silence is correct: agent telemetry is opt-in, and a machine that
+        // never ran `clocktopus agent setup` should notice nothing.
         return;
     }
     const raw = await readStdin();
     if (!raw)
         return;
-    // After the empty-stdin check on purpose: `agent doctor` proves the hook
-    // command resolves by running it with no payload, and that probe must not
-    // leave a stray process behind.
+    // After the empty-stdin check on purpose: `agent doctor` proves the hook command
+    // resolves by running it with no payload, and that probe must not leave a stray
+    // process behind.
     if (!agent.hostRunsHooksAsync && !detached) {
         if (await detachSelf(agent.provider, raw))
             return;
-        // Could not spawn — fall through and do it inline. A slow session start
-        // is worth more than a lost session.
+        // Could not spawn — fall through and do it inline. A slow session start is worth
+        // more than a lost one.
     }
     let payload;
     try {
@@ -260,13 +269,10 @@ async function run(agent, detached) {
         return;
     const eventName = typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
     const isSessionStart = eventName === "SessionStart";
-    // HEAD at SessionStart is the *before* SHA; HEAD at SessionEnd is the
-    // *after*. Sending both under one field would let SessionEnd overwrite the
-    // start SHA, collapsing the range to a single point and making
-    // `git rev-list before..after` — the authoritative commit↔session link —
-    // impossible to compute.
+    // HEAD at SessionStart is the *before* SHA, at SessionEnd the *after*. Kept as two
+    // fields so SessionEnd cannot overwrite the start SHA; the commits themselves now
+    // come from the reflog, but the range is still what `repo-readiness` reports on.
     const head = git(cwd, ["rev-parse", "HEAD"]);
-    const repositoryUrl = git(cwd, ["remote", "get-url", "origin"]);
     const body = {
         provider: agent.provider,
         session_id: sessionId,
@@ -274,55 +280,56 @@ async function run(agent, detached) {
         cwd,
         source: typeof payload.source === "string" ? payload.source : undefined,
         reason: typeof payload.reason === "string" ? payload.reason : undefined,
-        repository_url: repositoryUrl,
+        ...remotesFor(cwd),
         git_branch: git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
         ...(isSessionStart ? { git_head_before: head } : { git_head_after: head }),
     };
-    // Resolve the SHA range into an actual commit list, here on the machine
-    // that has the git object graph. The receiver cannot do this — it has no
-    // checkout — so a range alone would be unusable.
-    //
-    // SessionStart and SessionEnd are separate processes, so the starting SHA
-    // is stashed on disk under the session id rather than passed in the
-    // environment.
+    // Resolve the session's commits here, on the machine that has the git object graph
+    // and the reflog — the receiver has neither. SessionStart and SessionEnd are separate
+    // processes, so the session's start is stashed on disk under the session id rather
+    // than passed in the environment.
     if (isSessionStart) {
-        if (head)
-            writeStartState(sessionId, { sha: head, cwd, provider: agent.provider });
+        // SessionStart fires again mid-session on `compact` and `resume`, and our hook is
+        // installed with no matcher, so it sees those too. Writing again would move
+        // `startedAt` forward and drop everything committed before the compaction out of
+        // the declared window — and move the server's `started_at` with it. The first
+        // stamp is the session's real start; keep it.
+        if (head && !readStartState(sessionId))
+            writeStartState(sessionId, {
+                sha: head,
+                cwd,
+                provider: agent.provider,
+                startedAt: new Date().toISOString(),
+            });
     }
     else {
-        const before = readStartState(sessionId)?.sha;
-        if (before && head && before !== head) {
-            const shas = git(cwd, [
-                "rev-list",
-                "--max-count=200",
-                `${before}..${head}`,
-            ]);
-            if (shas)
-                body.commit_shas = shas.split("\n").filter(Boolean);
-        }
+        const start = readStartState(sessionId);
+        const before = start?.sha;
+        const commitShas = declaredCommits(cwd, start?.startedAt);
+        if (commitShas.length > 0)
+            body.commit_shas = commitShas;
         if (before)
             body.git_head_before = before;
-        // A host that ends a session once is done with this file. One that can
-        // end it repeatedly — OpenCode, whose SessionEnd is `session.idle` after
-        // every turn — is not: deleting it here would cost the session every
-        // commit made after its first pause, because the next idle would have no
-        // starting SHA to diff against. Rewriting the *original* SHA keeps the
-        // range anchored at the session's start, so each idle re-declares the
-        // whole range; re-declaring is free, since a link is unique per commit
-        // and `declared` already outranks everything else.
+        // A host that ends a session once is done with this file. One that can end it
+        // repeatedly — OpenCode, whose SessionEnd is `session.idle` after every turn — is
+        // not: deleting it here would cost the session every commit made after its first
+        // pause. Rewriting the *original* SHA keeps the range anchored at the session's
+        // start, and re-declaring is free since a link is unique per commit.
         //
-        // Rewriting rather than leaving it also refreshes the file's mtime, which
-        // is what the sweep ages sessions by — so the 12h abandonment clock runs
-        // from the last turn rather than from session start, and a long
-        // conversation is not swept out from under itself.
+        // Rewriting also refreshes the file's mtime, which the sweep ages sessions by, so
+        // the 12h clock runs from the last turn and a long conversation is not swept out
+        // from under itself.
         if (agent.hostRepeatsSessionEnd && before) {
             writeStartState(sessionId, {
                 sha: before,
                 cwd,
                 provider: agent.provider,
-                // Already closed in the database. The sweep needs to know that, or
-                // it would "close" the session a second time 12h later and stamp it
-                // with whatever HEAD had become by then.
+                // Carried over with the SHA: the range stays anchored at the session's start, so
+                // the bound on it has to as well, or every turn after the first would declare
+                // against an unbounded range again.
+                startedAt: start?.startedAt,
+                // Already closed in the database. The sweep needs to know, or it would "close" the
+                // session again 12h later and stamp it with whatever HEAD had become by then.
                 closed: true,
             });
         }
@@ -330,9 +337,8 @@ async function run(agent, detached) {
             clearStartState(sessionId);
         }
     }
-    // transcript_path is intentionally NOT forwarded. Claude Code provides it,
-    // and it points at the full conversation on disk — exactly the content
-    // BLA-421 says we must never collect.
+    // transcript_path is intentionally NOT forwarded: it points at the full conversation
+    // on disk, exactly the content BLA-421 says we must never collect.
     const result = await post(endpoint, token, body);
     recordLastRun({
         at: new Date().toISOString(),
@@ -343,21 +349,19 @@ async function run(agent, detached) {
         tokenPrefix: maskToken(token),
         status: result.status,
         error: result.error,
-        repository: repositoryUrl ?? null,
+        repository: body.repository_url ?? null,
     });
-    // After this session's own event, never before it: the sweep talks to the
-    // network once per abandoned session and must not delay the event it is
-    // piggybacking on.
+    // After this session's own event, never before it: the sweep talks to the network
+    // once per abandoned session and must not delay the event it piggybacks on.
     if (isSessionStart) {
         await sweepAbandonedSessions(endpoint, token, sessionId, agent.provider);
     }
 }
 export async function hookCommand(options) {
     try {
-        // An unrecognised provider falls back to Claude Code rather than
-        // aborting: a hook installed by an older CLI has no flag at all, and
-        // dropping its sessions would be a worse failure than mislabelling a
-        // provider we do not know.
+        // An unrecognised provider falls back to Claude Code rather than aborting: a hook
+        // installed by an older CLI has no flag at all, and dropping its sessions would be a
+        // worse failure than mislabelling a provider we do not know.
         const agent = AGENTS.find((candidate) => candidate.provider === options.provider) ??
             AGENTS[0];
         await run(agent, options.detached === true);