@blastin-dev/clocktopus-cli 0.2.0 → 0.3.0

package/dist/src/lib/codex-config.test.js

@@ -0,0 +1,359 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { applyCodexHooks, applyCodexOtel, buildCodexOtel, CodexConfigParseError, readCodexConfig, readCodexHooks, readCodexHookTrust, readCodexTelemetry, removeCodexHooks, removeCodexOtel, spliceOtelSection, writeCodexConfig, writeCodexHooks, } from "./codex-config";
+/**
+ * These tests exist because this module edits two files we do not own.
+ * `~/.codex/config.toml` holds the user's model, sandbox policy, MCP
+ * servers and project trust decisions — hand-written and usually commented
+ * — and `hooks.json` may already hold hooks that have nothing to do with
+ * us. A merge bug here destroys work unrelated to Clocktopus.
+ */
+const INSTALL = {
+    token: "ctop_agt_testtoken",
+    endpoint: "https://otel.example.com",
+    hookCommand: "clocktopus agent hook --provider codex_cli",
+};
+/** A config.toml with the user's own settings, comments and layout. */
+const USER_CONFIG = `# my codex setup
+model = "gpt-5.6-sol"
+approval_policy = "on-request"
+
+[sandbox_workspace_write]
+network_access = true    # needed for npm
+
+[mcp_servers.linear]
+command = "npx"
+args = ["-y", "linear-mcp"]
+`;
+let dir;
+let configPath;
+let hooksPath;
+beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "clocktopus-codex-"));
+    configPath = join(dir, "config.toml");
+    hooksPath = join(dir, "hooks.json");
+});
+afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+});
+describe("buildCodexOtel", () => {
+    it("puts the receiver path on the endpoint, because Codex does not add one", () => {
+        const otel = buildCodexOtel(INSTALL);
+        const http = otel.exporter["otlp-http"];
+        // Codex POSTs to the configured URL verbatim — unlike the OTel SDK, it
+        // does not append `/v1/logs`. Omitting the path here would send every
+        // export to the receiver's root and 404 silently.
+        expect(http.endpoint).toBe("https://otel.example.com/v1/logs");
+        expect(http.protocol).toBe("json");
+        expect(http.headers.Authorization).toBe("Bearer ctop_agt_testtoken");
+    });
+    it("does not double the path when the endpoint already ends in a slash", () => {
+        const otel = buildCodexOtel({
+            ...INSTALL,
+            endpoint: "https://otel.example.com/",
+        });
+        const http = otel.exporter["otlp-http"];
+        expect(http.endpoint).toBe("https://otel.example.com/v1/logs");
+    });
+    it("turns prompt logging off explicitly rather than trusting the default", () => {
+        expect(buildCodexOtel(INSTALL).log_user_prompt).toBe(false);
+    });
+});
+describe("splicing [otel] into a hand-written config.toml", () => {
+    it("adds the section without disturbing comments or layout", () => {
+        const next = spliceOtelSection(USER_CONFIG, buildCodexOtel(INSTALL));
+        // Every line the user wrote survives, byte for byte. A round trip
+        // through a TOML serialiser would silently drop all three comments.
+        expect(next).toContain("# my codex setup");
+        expect(next).toContain("network_access = true    # needed for npm");
+        expect(next).toContain('args = ["-y", "linear-mcp"]');
+        const parsed = parseToml(next);
+        expect(parsed.model).toBe("gpt-5.6-sol");
+        expect(parsed.mcp_servers).toEqual({
+            linear: { command: "npx", args: ["-y", "linear-mcp"] },
+        });
+        expect(parsed.otel.log_user_prompt).toBe(false);
+    });
+    it("replaces an existing [otel] section instead of appending a second", () => {
+        const withOtel = spliceOtelSection(USER_CONFIG, buildCodexOtel(INSTALL));
+        const twice = spliceOtelSection(withOtel, buildCodexOtel({ ...INSTALL, token: "ctop_agt_second" }));
+        // TOML rejects a duplicated table outright, so an append bug here would
+        // stop Codex booting at all.
+        expect(twice.match(/^\[otel\]/gm)).toHaveLength(1);
+        expect(twice).toContain("ctop_agt_second");
+        expect(twice).not.toContain("ctop_agt_testtoken");
+        expect(() => parseToml(twice)).not.toThrow();
+    });
+    it("keeps the user's own [otel] keys when merging ours in", () => {
+        const config = `${USER_CONFIG}
+[otel]
+environment = "staging"
+`;
+        const parsed = parseToml(config);
+        const next = applyCodexOtel({ text: config, config: parsed }, INSTALL);
+        const result = parseToml(next);
+        expect(result.otel.environment).toBe("staging");
+        expect(result.otel.log_user_prompt).toBe(false);
+    });
+    it("removes only our keys, leaving the rest of [otel] behind", () => {
+        const config = `${USER_CONFIG}
+[otel]
+environment = "staging"
+`;
+        const withOurs = applyCodexOtel({ text: config, config: parseToml(config) }, INSTALL);
+        const { nextText, removedKeys } = removeCodexOtel({
+            text: withOurs,
+            config: parseToml(withOurs),
+        });
+        expect(removedKeys.sort()).toEqual(["exporter", "log_user_prompt"]);
+        const parsed = parseToml(nextText);
+        expect(parsed.otel).toEqual({ environment: "staging" });
+        expect(parsed.model).toBe("gpt-5.6-sol");
+    });
+    it("drops [otel] entirely when nothing of the user's is left in it", () => {
+        const withOurs = spliceOtelSection(USER_CONFIG, buildCodexOtel(INSTALL));
+        const { nextText } = removeCodexOtel({
+            text: withOurs,
+            config: parseToml(withOurs),
+        });
+        expect(nextText).not.toContain("[otel]");
+        expect(parseToml(nextText)).toEqual(parseToml(USER_CONFIG));
+    });
+    it("survives an add/remove cycle without accumulating blank lines", () => {
+        let text = USER_CONFIG;
+        for (let i = 0; i < 3; i++) {
+            text = spliceOtelSection(text, buildCodexOtel(INSTALL));
+            text = removeCodexOtel({
+                text,
+                config: parseToml(text),
+            }).nextText;
+        }
+        expect(text).toBe(USER_CONFIG);
+    });
+    it("creates the section from nothing when the file does not exist yet", () => {
+        const next = spliceOtelSection("", buildCodexOtel(INSTALL));
+        expect(parseToml(next).otel).toBeDefined();
+    });
+});
+describe("writeCodexConfig — the guard on the splice", () => {
+    it("writes the edit and backs up what was there", () => {
+        writeFileSync(configPath, USER_CONFIG);
+        const current = readCodexConfig(configPath);
+        const { backupPath } = writeCodexConfig({
+            path: configPath,
+            previousText: current.text,
+            previousConfig: current.config,
+            nextText: applyCodexOtel(current, INSTALL),
+        });
+        expect(backupPath).toBe(`${configPath}.clocktopus-backup`);
+        expect(readFileSync(backupPath, "utf8")).toBe(USER_CONFIG);
+        expect(readCodexTelemetry(configPath).token).toBe(INSTALL.token);
+    });
+    it("refuses to write an edit that would change anything outside [otel]", () => {
+        writeFileSync(configPath, USER_CONFIG);
+        const current = readCodexConfig(configPath);
+        // Stands in for a splice that misread the file's layout. Rather than
+        // trusting the region scanner, the write verifies its own result — so a
+        // document it cannot handle costs the user nothing.
+        expect(() => writeCodexConfig({
+            path: configPath,
+            previousText: current.text,
+            previousConfig: current.config,
+            nextText: 'model = "gpt-5.6-sol"\n',
+        })).toThrow(/would have changed/);
+        expect(readFileSync(configPath, "utf8")).toBe(USER_CONFIG);
+    });
+    it("refuses to write anything that is not valid TOML", () => {
+        writeFileSync(configPath, USER_CONFIG);
+        const current = readCodexConfig(configPath);
+        expect(() => writeCodexConfig({
+            path: configPath,
+            previousText: current.text,
+            previousConfig: current.config,
+            nextText: "[[[nope",
+        })).toThrow(/did not produce valid TOML/);
+        expect(readFileSync(configPath, "utf8")).toBe(USER_CONFIG);
+    });
+    it("raises rather than overwriting a config.toml it cannot parse", () => {
+        // Far more likely a half-finished edit than something to clobber.
+        writeFileSync(configPath, "model = = =");
+        expect(() => readCodexConfig(configPath)).toThrow(CodexConfigParseError);
+    });
+});
+describe("readCodexTelemetry", () => {
+    it("strips the receiver path back off so the hook gets a base URL", () => {
+        writeFileSync(configPath, spliceOtelSection(USER_CONFIG, buildCodexOtel(INSTALL)));
+        const telemetry = readCodexTelemetry(configPath);
+        // The hook posts to `<endpoint>/v1/agent-session` and doctor to
+        // `<endpoint>/v1/verify`; leaving `/v1/logs` on would make both 404.
+        expect(telemetry.endpoint).toBe("https://otel.example.com");
+        expect(telemetry.token).toBe(INSTALL.token);
+        expect(telemetry.protocol).toBe("json");
+    });
+    it("reports nothing configured rather than throwing on a missing file", () => {
+        expect(readCodexTelemetry(configPath)).toMatchObject({
+            exists: false,
+            token: null,
+            endpoint: null,
+        });
+    });
+});
+describe("hooks.json", () => {
+    /** Reads one event's matcher groups back out with the shape Codex expects. */
+    const groups = (file, event) => file.hooks[event] ?? [];
+    const userHooks = () => ({
+        description: "my hooks",
+        hooks: {
+            SessionStart: [
+                { hooks: [{ type: "command", command: "echo user-session-start" }] },
+            ],
+            PreToolUse: [
+                { matcher: "shell", hooks: [{ type: "command", command: "echo pre" }] },
+            ],
+        },
+    });
+    it("appends our hook without removing the user's", () => {
+        const next = applyCodexHooks(userHooks(), INSTALL);
+        const start = groups(next, "SessionStart");
+        expect(start).toHaveLength(2);
+        expect(start[0].hooks[0].command).toBe("echo user-session-start");
+        expect(start[1].hooks[0].command).toBe(INSTALL.hookCommand);
+        expect(groups(next, "PreToolUse")).toEqual(userHooks().hooks.PreToolUse);
+    });
+    it("gives SessionEnd the 3s budget Codex clamps it to", () => {
+        const next = applyCodexHooks({}, INSTALL);
+        // Codex hard-clamps SessionEnd and prints a warning on every session
+        // start if we ask for more. 10s for SessionStart, which it honours.
+        expect(groups(next, "SessionStart")[0].hooks[0].timeout).toBe(10);
+        expect(groups(next, "SessionEnd")[0].hooks[0].timeout).toBe(3);
+    });
+    it("never writes an `async` key, on either event", () => {
+        // The regression this pins cost a real user their repository
+        // attribution. Codex 0.147 does not skip an async hook quietly-ish and
+        // carry on: it drops SessionStart entirely, so `cwd` — the only source
+        // of repository, branch and starting SHA anywhere in the pipeline —
+        // never arrives, while spend keeps flowing in unattributed. 0.148
+        // honours it on SessionStart but still forces SessionEnd synchronous
+        // and warns once per session.
+        //
+        // `agent hook` backgrounds itself instead, so this key has no upside on
+        // any version.
+        const next = applyCodexHooks({}, INSTALL);
+        for (const event of ["SessionStart", "SessionEnd"]) {
+            const entry = groups(next, event)[0].hooks[0];
+            expect(entry).not.toHaveProperty("async");
+        }
+    });
+    it("replaces our hook on re-run instead of installing a second", () => {
+        const once = applyCodexHooks(userHooks(), INSTALL);
+        const twice = applyCodexHooks(once, {
+            hookCommand: "/usr/local/bin/clocktopus agent hook --provider codex_cli",
+        });
+        // Two of our hooks would POST every SessionStart twice.
+        const start = groups(twice, "SessionStart");
+        expect(start).toHaveLength(2);
+        expect(start[1].hooks[0].command).toContain("/usr/local/bin/clocktopus");
+    });
+    it("removes ours and leaves the user's intact", () => {
+        const installed = applyCodexHooks(userHooks(), INSTALL);
+        const { file, removed } = removeCodexHooks(installed);
+        expect(removed).toBe(true);
+        expect(file).toMatchObject({ hooks: userHooks().hooks });
+    });
+    it("round-trips through disk and finds our command again", () => {
+        writeCodexHooks(applyCodexHooks(userHooks(), INSTALL), hooksPath);
+        const read = readCodexHooks(hooksPath);
+        expect(read.commands.SessionStart).toBe(INSTALL.hookCommand);
+        expect(read.commands.SessionEnd).toBe(INSTALL.hookCommand);
+    });
+    it("raises rather than overwriting a hooks.json it cannot parse", () => {
+        writeFileSync(hooksPath, "{ not json");
+        expect(() => readCodexHooks(hooksPath)).toThrow(CodexConfigParseError);
+    });
+});
+describe("readCodexHookTrust — Codex's per-entry trust records", () => {
+    /**
+     * The key format is taken verbatim from a real `~/.codex/config.toml`
+     * after Codex 0.147 prompted and the answer was persisted. Trust is
+     * recorded per hook *entry* — `<path>:<event>:<group>:<index>` — not per
+     * file, which an earlier version of this function assumed; matching the
+     * bare path found nothing and reported a correctly-approved install as
+     * still pending, forever.
+     */
+    const trustState = (entries) => `[hooks.state]\n${entries
+        .map((key) => `\n[hooks.state."${key}"]\ntrusted_hash = "sha256:c3ffbe52"\nenabled = true\n`)
+        .join("")}`;
+    it("reads a fully approved install", () => {
+        writeFileSync(configPath, trustState([
+            `${hooksPath}:session_start:0:0`,
+            `${hooksPath}:session_end:0:0`,
+        ]));
+        // `hooksPath` is the temp dir's file, so point the reader at it too.
+        process.env.CODEX_HOME = dir;
+        try {
+            expect(readCodexHookTrust(configPath)).toEqual({
+                trusted: ["SessionStart", "SessionEnd"],
+                untrusted: [],
+            });
+        }
+        finally {
+            delete process.env.CODEX_HOME;
+        }
+    });
+    it("spots the half-approved install that loses repository context", () => {
+        // Exactly the state an `async: true` SessionStart left behind on Codex
+        // 0.147: the hook was skipped outright, so it was never offered for
+        // approval, while SessionEnd was. Sessions close but never open.
+        writeFileSync(configPath, trustState([`${hooksPath}:session_end:0:0`]));
+        process.env.CODEX_HOME = dir;
+        try {
+            expect(readCodexHookTrust(configPath)).toEqual({
+                trusted: ["SessionEnd"],
+                untrusted: ["SessionStart"],
+            });
+        }
+        finally {
+            delete process.env.CODEX_HOME;
+        }
+    });
+    it("reads Codex 0.148's hash-only record, which omits `enabled`", () => {
+        // 0.148 persists `hooks.state."<key>".trusted_hash` and nothing else —
+        // its `HookStateToml` has no `enabled` field. Demanding `enabled = true`
+        // reported a just-approved install as still pending, and no amount of
+        // restarting Codex could clear it: it never prompts again once trusted.
+        writeFileSync(configPath, `[hooks.state."${hooksPath}:session_start:0:0"]\ntrusted_hash = "sha256:c3ffbe52"\n` +
+            `\n[hooks.state."${hooksPath}:session_end:0:0"]\ntrusted_hash = "sha256:8b152fa9"\nenabled = true\n`);
+        process.env.CODEX_HOME = dir;
+        try {
+            expect(readCodexHookTrust(configPath)).toEqual({
+                trusted: ["SessionStart", "SessionEnd"],
+                untrusted: [],
+            });
+        }
+        finally {
+            delete process.env.CODEX_HOME;
+        }
+    });
+    it("treats an entry the user explicitly disabled as untrusted", () => {
+        writeFileSync(configPath, `[hooks.state."${hooksPath}:session_start:0:0"]\ntrusted_hash = "sha256:c3ffbe52"\nenabled = false\n`);
+        process.env.CODEX_HOME = dir;
+        try {
+            expect(readCodexHookTrust(configPath).untrusted).toEqual([
+                "SessionStart",
+                "SessionEnd",
+            ]);
+        }
+        finally {
+            delete process.env.CODEX_HOME;
+        }
+    });
+    it("reports everything untrusted when there is no config at all", () => {
+        expect(readCodexHookTrust(join(dir, "missing.toml")).untrusted).toEqual([
+            "SessionStart",
+            "SessionEnd",
+        ]);
+    });
+});

package/dist/src/lib/declared-commits.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Arguments for reading the session's slice of the reflog, or `null` when the
+ * session's start was never recorded.
+ *
+ * A null return means *declare nothing*, deliberately. Without a lower bound the
+ * reflog would hand back the checkout's entire history; the time-window rule already
+ * covers a session that cannot declare, and over-declaring is the one mistake it
+ * cannot undo — a `declared` link outranks the window and is permanent.
+ */
+export declare function buildReflogArgs(input: {
+    /** ISO timestamp recorded at SessionStart. */
+    startedAt?: string;
+    /** Upper bound, for the sweep: a session that died hours ago owns nothing since. */
+    until?: string;
+}): string[] | null;
+/**
+ * The commits created in this checkout, newest first, from `buildReflogArgs` output.
+ *
+ * Three actions always author a commit here and are kept: `commit` (with its
+ * `(initial)`, `(amend)` and `(merge)` variants), `revert` and `cherry-pick`.
+ * `checkout` and `reset` move HEAD without writing anything.
+ *
+ * **`merge` and `pull` are excluded even though a clean merge does author a commit**,
+ * because nothing in the reflog separates one you made from one you fast-forwarded
+ * onto. Parent count looks like it would and does not — a plain `git pull` on a
+ * repository that merges its pull requests lands on a two-parent commit somebody else
+ * wrote:
+ *
+ *     parents=14c3726 6d88961 | pull: Fast-forward
+ *
+ * A conflicted merge is still caught, since resolving one ends in `commit (merge)`.
+ * A clean one falls to the time-window rule.
+ *
+ * `rebase (pick)` is excluded for the matching reason: replaying a branch would
+ * declare every commit on it, including work authored long before the session. The
+ * cost is that a session which commits and then rebases declares the pre-rebase SHA,
+ * which was never pushed and simply joins to nothing.
+ *
+ * Every exclusion here is recoverable and every wrong inclusion is not: a `declared`
+ * link outranks the time window and is permanent.
+ */
+export declare function parseReflogCommits(output: string | undefined): string[];
+//# sourceMappingURL=declared-commits.d.ts.map

package/dist/src/lib/declared-commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-commits.d.ts","sourceRoot":"","sources":["../../../src/lib/declared-commits.ts"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,EAAE,GAAG,IAAI,CA2BlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAyBvE"}

package/dist/src/lib/declared-commits.js

@@ -0,0 +1,114 @@
+// Resolving the commits a session actually created.
+//
+// The obvious answer, `git rev-list before..head`, answers a different question:
+// "what is reachable from here that was not reachable from there". Merged and pulled
+// history is reachable, so it gets declared — one real session claimed 105 commits
+// reaching two months back (BLA-595) — and a mid-session switch to a *pre-existing*
+// branch makes the session's own earlier commits unreachable, so they vanish.
+//
+// The reflog answers the right question. It records HEAD movements in this checkout,
+// tagged with what caused them, so a `pull` or a `merge` is one entry rather than one
+// per commit it brought along, and a branch switch is irrelevant to what was authored.
+// It is also per-worktree (`.git/worktrees/<name>/logs/HEAD`), so parallel agents in
+// separate worktrees observe disjoint histories and cannot both claim a commit.
+//
+// Two agents in one worktree share a reflog and remain genuinely indistinguishable.
+// That is a real limit, not an oversight.
+/** Ceiling on what one session may declare. */
+const MAX_DECLARED_COMMITS = 200;
+/**
+ * Arguments for reading the session's slice of the reflog, or `null` when the
+ * session's start was never recorded.
+ *
+ * A null return means *declare nothing*, deliberately. Without a lower bound the
+ * reflog would hand back the checkout's entire history; the time-window rule already
+ * covers a session that cannot declare, and over-declaring is the one mistake it
+ * cannot undo — a `declared` link outranks the window and is permanent.
+ */
+export function buildReflogArgs(input) {
+    // No grace before `startedAt`, deliberately. Both timestamps come from the same
+    // machine clock, so there is no skew to absorb, and SessionStart fires before the
+    // agent can act, so nothing it wrote can predate the stamp. A backward grace could
+    // therefore only admit a commit made *before* the session — the `wip` a developer
+    // makes just before launching an agent — as `declared`, which outranks the time
+    // window and is permanent. `--prune` cannot undo it either: that cuts at an hour.
+    const since = asIso(input.startedAt);
+    if (!since)
+        return null;
+    const args = [
+        "reflog",
+        "show",
+        "HEAD",
+        "--format=%H %gs",
+        `--since=${since}`,
+    ];
+    const until = asIso(input.until);
+    if (until)
+        args.push(`--until=${until}`);
+    // A working tree containing a file called `HEAD` makes git refuse the whole read —
+    // "ambiguous argument 'HEAD': both revision and filename" — which `git()` swallows,
+    // so the session would silently declare nothing.
+    args.push("--");
+    return args;
+}
+/**
+ * The commits created in this checkout, newest first, from `buildReflogArgs` output.
+ *
+ * Three actions always author a commit here and are kept: `commit` (with its
+ * `(initial)`, `(amend)` and `(merge)` variants), `revert` and `cherry-pick`.
+ * `checkout` and `reset` move HEAD without writing anything.
+ *
+ * **`merge` and `pull` are excluded even though a clean merge does author a commit**,
+ * because nothing in the reflog separates one you made from one you fast-forwarded
+ * onto. Parent count looks like it would and does not — a plain `git pull` on a
+ * repository that merges its pull requests lands on a two-parent commit somebody else
+ * wrote:
+ *
+ *     parents=14c3726 6d88961 | pull: Fast-forward
+ *
+ * A conflicted merge is still caught, since resolving one ends in `commit (merge)`.
+ * A clean one falls to the time-window rule.
+ *
+ * `rebase (pick)` is excluded for the matching reason: replaying a branch would
+ * declare every commit on it, including work authored long before the session. The
+ * cost is that a session which commits and then rebases declares the pre-rebase SHA,
+ * which was never pushed and simply joins to nothing.
+ *
+ * Every exclusion here is recoverable and every wrong inclusion is not: a `declared`
+ * link outranks the time window and is permanent.
+ */
+export function parseReflogCommits(output) {
+    if (!output?.trim())
+        return [];
+    const shas = [];
+    const seen = new Set();
+    for (const line of output.split("\n")) {
+        // The SHA can contain no spaces, so the first one ends it; the subject keeps its
+        // own.
+        const separator = line.indexOf(" ");
+        if (separator === -1)
+            continue;
+        const sha = line.slice(0, separator).trim();
+        const subject = line.slice(separator + 1).trim();
+        if (!/^[0-9a-f]{7,64}$/i.test(sha))
+            continue;
+        if (!/^(commit|revert|cherry-pick)\b/.test(subject))
+            continue;
+        if (seen.has(sha))
+            continue;
+        seen.add(sha);
+        shas.push(sha);
+        if (shas.length === MAX_DECLARED_COMMITS)
+            break;
+    }
+    return shas;
+}
+function asIso(value) {
+    return asDate(value)?.toISOString() ?? null;
+}
+function asDate(value) {
+    if (!value)
+        return null;
+    const at = new Date(value);
+    return Number.isNaN(at.getTime()) ? null : at;
+}

package/dist/src/lib/declared-commits.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=declared-commits.test.d.ts.map

package/dist/src/lib/declared-commits.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-commits.test.d.ts","sourceRoot":"","sources":["../../../src/lib/declared-commits.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/declared-commits.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest";
+import { buildReflogArgs, parseReflogCommits } from "./declared-commits.js";
+const STARTED_AT = "2026-08-20T05:35:45.728Z";
+const SHA = "418a320a048f839f2200106fbcffbb6f7683d135";
+const reflog = (...lines) => lines.join("\n");
+describe("buildReflogArgs", () => {
+    it("bounds the read at the session start exactly", () => {
+        expect(buildReflogArgs({ startedAt: STARTED_AT })).toContain(`--since=${STARTED_AT}`);
+    });
+    /**
+     * No backward grace. Both stamps come from one machine clock, and SessionStart fires
+     * before the agent can act, so a grace could only admit a commit made *before* the
+     * session — as `declared`, which outranks the time window and is permanent.
+     */
+    it("admits nothing committed before the session started", () => {
+        const args = buildReflogArgs({ startedAt: STARTED_AT });
+        const since = args
+            .find((arg) => arg.startsWith("--since="))
+            .replace("--since=", "");
+        expect(new Date(since).getTime()).toBe(new Date(STARTED_AT).getTime());
+    });
+    /** The sweep runs hours late; a session that died owns nothing committed since. */
+    it("takes an upper bound, for the sweep", () => {
+        const args = buildReflogArgs({
+            startedAt: STARTED_AT,
+            until: "2026-08-20T11:56:30.103Z",
+        });
+        expect(args).toContain("--until=2026-08-20T11:56:30.103Z");
+    });
+    /**
+     * A working tree with a file called `HEAD` otherwise makes git refuse the read
+     * outright — "ambiguous argument 'HEAD': both revision and filename".
+     */
+    it("separates the revision from any path of the same name", () => {
+        expect(buildReflogArgs({ startedAt: STARTED_AT }).at(-1)).toBe("--");
+    });
+    it("omits the upper bound for a live SessionEnd", () => {
+        const args = buildReflogArgs({ startedAt: STARTED_AT });
+        expect(args.some((arg) => arg.startsWith("--until="))).toBe(false);
+    });
+    /**
+     * Declaring nothing is the deliberate answer. Without a lower bound the reflog is
+     * the checkout's entire history, and a `declared` link outranks the time window, so
+     * over-declaring is the one mistake that cannot be undone later.
+     */
+    it("refuses to read at all when the session start was never recorded", () => {
+        expect(buildReflogArgs({})).toBeNull();
+        expect(buildReflogArgs({ startedAt: "not a date" })).toBeNull();
+    });
+});
+describe("parseReflogCommits", () => {
+    it("takes the commits this checkout authored", () => {
+        const shas = parseReflogCommits(reflog(`${SHA} commit: fix(bla-597): read the reflog`, "cd72bebc2ce64099f27f28e251be57cb53189328 commit (merge): merge the release branch"));
+        expect(shas).toEqual([SHA, "cd72bebc2ce64099f27f28e251be57cb53189328"]);
+    });
+    it("takes a revert and a cherry-pick, which always author here", () => {
+        const shas = parseReflogCommits(reflog('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa revert: Revert "feat: c2"', "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb cherry-pick: feat: c3"));
+        expect(shas).toHaveLength(2);
+    });
+    /**
+     * Parent count looks like it would separate a merge you made from one you
+     * fast-forwarded onto, and does not: a plain `git pull` on a repository that merges
+     * its pull requests lands on a two-parent commit somebody else wrote. So merges are
+     * excluded, and a conflicted one is still caught as `commit (merge)`.
+     */
+    it("ignores a clean merge rather than risk claiming a pulled one", () => {
+        const shas = parseReflogCommits(reflog("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa merge side: Merge made by the 'ort' strategy.", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb pull: Fast-forward"));
+        expect(shas).toEqual([]);
+    });
+    /**
+     * The whole point. A pull or a merge is one reflog entry however much history it
+     * brings — the range that replaced this declared 118 commits for one such merge.
+     */
+    it("ignores history that merely arrived in the checkout", () => {
+        const shas = parseReflogCommits(reflog("4257246e3860ef8d834e4e4efbb7ed0da648ad23 pull: Fast-forward", "9f0ae840a64bae586d8e816124278ee0212ad0cc merge develop: Merge made by the 'ort' strategy.", "64d934042b0568a7acded2b059148dbc8f36ac83 checkout: moving from develop to a-branch", "6f59f8ad63a21000406480c17e766ea0706dff70 reset: moving to HEAD~1"));
+        expect(shas).toEqual([]);
+    });
+    /**
+     * A rebase writes new objects, but replaying a branch would declare work authored
+     * long before the session. Excluded; the pushed SHAs fall to the time-window rule.
+     */
+    it("ignores rebase replays", () => {
+        const shas = parseReflogCommits(reflog("64d934042b0568a7acded2b059148dbc8f36ac83 rebase (start): checkout develop", "cd72bebc2ce64099f27f28e251be57cb53189328 rebase (pick): fix(bla-595): bound the range", "cd72bebc2ce64099f27f28e251be57cb53189328 rebase (finish): returning to a-branch"));
+        expect(shas).toEqual([]);
+    });
+    it("keeps an amend, whose old and new SHAs are both reflog commits", () => {
+        const shas = parseReflogCommits(reflog("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa commit (amend): fix(bla-597): reworded", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb commit: fix(bla-597): original"));
+        // Only the amended SHA is ever pushed; the original simply joins to nothing.
+        expect(shas).toHaveLength(2);
+    });
+    it("keeps an initial commit", () => {
+        expect(parseReflogCommits(`${SHA} commit (initial): base`)).toEqual([SHA]);
+    });
+    it("survives a subject containing the field separator", () => {
+        const shas = parseReflogCommits(`${SHA} commit: fix(bla-597): read HEAD, then the reflog`);
+        expect(shas).toEqual([SHA]);
+    });
+    it("does not repeat a SHA HEAD returned to", () => {
+        const shas = parseReflogCommits(reflog(`${SHA} commit: one`, `${SHA} commit (amend): one, reworded`));
+        expect(shas).toEqual([SHA]);
+    });
+    it("returns nothing for an empty or unreadable reflog", () => {
+        expect(parseReflogCommits("")).toEqual([]);
+        expect(parseReflogCommits(undefined)).toEqual([]);
+        expect(parseReflogCommits("not a reflog line")).toEqual([]);
+    });
+    it("caps what one session may declare", () => {
+        const lines = Array.from({ length: 250 }, (_, i) => `${i.toString(16).padStart(40, "0")} commit: commit ${i}`);
+        expect(parseReflogCommits(reflog(...lines))).toHaveLength(200);
+    });
+});
+/**
+ * The sweep's upper bound is the state file's mtime, which is only a record of "last
+ * activity" on a host that rewrites the file as the session goes. Everywhere else the
+ * file is written once at SessionStart, so `until` equals `startedAt` and the window
+ * collapses onto a point — which is why `sweptCommits` refuses to read it at all for
+ * those hosts rather than relying on this shape.
+ */
+describe("the window a sweep would ask for", () => {
+    it("collapses to a point when until is the session start", () => {
+        const args = buildReflogArgs({
+            startedAt: STARTED_AT,
+            until: STARTED_AT,
+        });
+        const since = args.find((a) => a.startsWith("--since=")).slice(8);
+        const until = args.find((a) => a.startsWith("--until=")).slice(8);
+        expect(new Date(since).getTime()).toBe(new Date(until).getTime());
+    });
+});

package/dist/src/lib/git-remotes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parses `git remote -v` into a deduplicated URL list, `origin` first.
+ *
+ * Order is load-bearing in one narrow way: the first entry is what a receiver older
+ * than BLA-598 reads as the only remote, so keeping `origin` there preserves the
+ * previous behaviour exactly.
+ */
+export declare function parseGitRemotes(output: string | undefined): string[];
+//# sourceMappingURL=git-remotes.d.ts.map

package/dist/src/lib/git-remotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-remotes.d.ts","sourceRoot":"","sources":["../../../src/lib/git-remotes.ts"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAkCpE"}