kankaku-claude 0.2.2 → 0.10.0

package/.claude-plugin/plugin.json

@@ -1,11 +1,11 @@
 {
   "name": "kankaku",
   "description": "Records how long Claude Code works on each of your prompts: wall time, waiting time, work time and cost, per prompt, in kankaku's worklog format.",
-  "version": "0.1.0",
+  "version": "0.10.0",
   "author": {
     "name": "soyunninja"
   },
   "homepage": "https://kankaku.io",
-  "repository": "https://github.com/soyunninja/kankaku-claude",
+  "repository": "https://github.com/soyunninja/kankaku",
   "license": "MIT"
 }

package/CHANGELOG.md

@@ -4,7 +4,35 @@ All notable changes to this project are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [Unreleased]
+## 0.10.0 — 2026-09-28
+
+### Fixed
+
+- **Installed as a dependency, the plugin could not run at all.** This
+  package now compiles to `dist/` (`npm run build`, `tsc -p
+  tsconfig.build.json`) and ships `dist/` instead of `src/`/`tsconfig.json`
+  in `package.json`'s `files`. Every hook/statusline/CLI command
+  (`hooks/hooks.json`, `commands/*.md`, the `statusLine` snippet
+  `kankaku setup`/`/kankaku:setup` prints) now points at the compiled
+  `dist/*.js`, never `src/*.ts` — Node 24 refuses to type-strip a `.ts`
+  file once it sits under a `node_modules` directory
+  (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), so a `kankaku-tui`
+  install of this package (its dependency, not a checkout) could not run
+  a single hook, the statusline, or the CLI before this fix. `npm run
+  check`/`prepublishOnly` build first; a manual `--plugin-dir` checkout
+  now needs `npm install && npm run build` once (see README "Install").
+
+### Changed
+
+- README "Install": the recommended path is now `npm i -g kankaku-tui &&
+  kankaku setup` — `kankaku-tui` depends on this package directly and its
+  setup wizard/`--yes` flow writes both `statusLine` and `hooks` into
+  `~/.claude/settings.json` in one step, so no checkout or `--plugin-dir`
+  is required for the plugin to measure time or report cost.
+  `--plugin-dir <checkout>` remains documented as the manual/dev path
+  (also the only way to get the `/kankaku:*` slash commands), with a note
+  that combining it with a `kankaku setup`-configured machine double-runs
+  the hooks and double-writes worklog records.
 
 ### Added
 
@@ -62,3 +90,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   - `SessionEnd` also deletes the session's cost file; `SessionStart`
     (non-`compact`) sweeps cost files older than 7 days.
   - `node src/cli.ts status` reads cost from the cost file.
+
+## 0.9.0 — 2026-09-28
+
+### Changed
+
+- Moved into the kankaku monorepo (`github.com/soyunninja/kankaku`,
+  `packages/claude`); versions are now lockstep with the other client
+  packages (`kankaku`, `kankaku-tui`). Depends on `kankaku ^0.9.0` (was
+  `^0.6.0`). No behaviour change.

package/README.md

@@ -4,6 +4,9 @@ A [Claude Code](https://claude.com/claude-code) plugin that records how long
 Claude Code works on each of your prompts, in the same worklog format as the
 [kankaku](https://kankaku.io) pi extension.
 
+This package lives in the [kankaku monorepo](https://github.com/soyunninja/kankaku),
+under `packages/claude`.
+
 ## What it measures
 
 One record per user prompt, appended to `<KANKAKU_DIR>/worklog.jsonl`:
@@ -25,22 +28,67 @@ manual and best-effort automatic hub sync through kankaku's public hub adapters
 ## Requirements
 
 - Claude Code with plugin support.
-- Node.js >= 24 on `PATH` (this package's `.ts` sources run directly under
-  Node's built-in type stripping; there is no build step).
+- Node.js >= 24 on `PATH`. This package ships a compiled `dist/` (`npm
+  run build`, `tsc -p tsconfig.build.json`) — Node refuses to type-strip
+  a `.ts` file once it sits under a `node_modules` directory
+  (`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`), so every published
+  hook/statusline/CLI command runs the built `dist/*.js` file, never the
+  `.ts` source. Installed via `kankaku-tui` (below) this needs no action
+  from you; a manual `--plugin-dir` checkout must run `npm install && npm
+  run build` once before Claude Code can load it (see "Manual/dev"
+  below).
 
 ## Install
 
-**From a local path (development).** Clone this repository, then point
-Claude Code at it directly:
+**Recommended: `kankaku-tui`'s setup wizard.** This package lives inside
+`kankaku-tui`'s own dependency tree, so installing and running its setup
+wizard configures Claude Code for you — statusline and hooks together, in
+one step, with no checkout and no `--plugin-dir`:
+
+```bash
+npm i -g kankaku-tui
+kankaku setup
+```
+
+Checking Claude Code in the wizard (or confirming it in `kankaku setup
+--yes`) writes `statusLine` and `hooks` into `~/.claude/settings.json`,
+resolved from this package's own bundled files, merged with — never
+clobbering — whatever else is already there. See `kankaku-tui`'s own
+README ("Claude Code") for the full behaviour, the
+`--claude-plugin-dir`/`KANKAKU_CLAUDE_PLUGIN_DIR` override, and why you
+should drop `--plugin-dir` (below) once this has run.
+
+**Manual/dev: `--plugin-dir` (also required for the `/kankaku:*` slash
+commands).** Clone this repository, build it once, then point Claude Code
+at it directly:
 
 ```bash
+git clone https://github.com/soyunninja/kankaku.git
+cd kankaku/packages/claude
+npm install && npm run build
 claude --plugin-dir /path/to/kankaku-claude
 ```
 
+`npm run build` compiles `src/` into `dist/`; the hooks, statusline and
+`/kankaku:*` commands all run `dist/*.js`, never `src/*.ts` — a checkout
+that skips this step fails at the hook's very first launch with
+`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` (or, for `--plugin-dir`
+itself, simply nothing recorded). Re-run `npm run build` after pulling
+new commits.
+
 If your Claude Code version does not recognize `--plugin-dir`, or plugin
 loading has changed since this was written, check your installed version's
 own plugin documentation (`claude --help`, or `/plugin` inside a session) for
-the current local-install flow.
+the current local-install flow. `--plugin-dir` is also the only way to get
+the `/kankaku:*` slash commands (`/kankaku:report`, `/kankaku:setup`, …),
+since a Claude Code plugin loaded only through settings.json hooks — the
+recommended path above — never registers commands.
+
+**Do not combine the two.** If `kankaku setup` has already configured this
+machine's `~/.claude/settings.json` hooks, loading the plugin again with
+`--plugin-dir` runs the same hooks twice per event and double-writes
+worklog records. Use `--plugin-dir` only on a machine `kankaku setup` has
+not touched, or drop it once setup has run.
 
 **From a marketplace.** Once this plugin is published to a marketplace:
 
@@ -58,7 +106,8 @@ there never blocks the plugin from loading.
 Claude Code plugins cannot set `statusLine` for themselves — there is no
 programmatic way for a plugin to add a `statusLine` entry to your settings.
 The statusline is also the *only* documented source of per-prompt cost
-(`cost.total_cost_usd`); hooks never receive it. So, once installed, run:
+(`cost.total_cost_usd`); hooks never receive it. `kankaku setup` (above)
+writes it for you automatically; without `kankaku-tui`, run:
 
 ```
 /kankaku:setup
@@ -79,22 +128,22 @@ anything behind in whatever project happens to be open.
 ## Commands
 
 - `/kankaku:report` — a report of recent work, grouped by day (wraps
-  `node src/cli.ts report`).
+  `node dist/cli.js report`).
 - `/kankaku:status` — the sessions kankaku-claude currently has state for:
   session id, whether its process is still alive, whether a prompt is open,
-  and the last cost the statusline reported (wraps `node src/cli.ts status`).
+  and the last cost the statusline reported (wraps `node dist/cli.js status`).
 - `/kankaku:setup` — prints the `statusLine` snippet described above (wraps
-  `node src/cli.ts setup`).
+  `node dist/cli.js setup`).
 - `/kankaku:sync` — manually syncs recent local work records to the hub
-  (wraps `node src/cli.ts sync`; the slash command does not forward arguments).
+  (wraps `node dist/cli.js sync`; the slash command does not forward arguments).
 - `/kankaku:sync-status` — inspects local pending counts and sync state
-  (wraps `node src/cli.ts sync status`; no hub request or credentials required).
-- `/kankaku:sync-all` — requests a full sync (wraps `node src/cli.ts sync all`).
+  (wraps `node dist/cli.js sync status`; no hub request or credentials required).
+- `/kankaku:sync-all` — requests a full sync (wraps `node dist/cli.js sync all`).
 - `/kankaku:doctor` — a read-only local diagnostic of plugin files, session and
-  cost visibility, and hub sync state (wraps `node src/cli.ts doctor`).
+  cost visibility, and hub sync state (wraps `node dist/cli.js doctor`).
 
 The report, status, setup, and doctor subcommands are also available directly via
-`node src/cli.ts <report|status|setup|doctor>`; `report` accepts `--days N` and
+`node dist/cli.js <report|status|setup|doctor>`; `report` accepts `--days N` and
 defaults to the last 7 days. Doctor reads only local data; it never contacts the
 hub or prints credentials. A missing cost file means cost has not been observed
 under the current `HOME` (it does not prove the statusline is misconfigured).
@@ -111,9 +160,9 @@ request or credentials. The same operations are available directly via CLI:
 
 | Command | Purpose |
 |---------|---------|
-| `node src/cli.ts sync` | Manually sync the recent window (24 hours by default). |
-| `node src/cli.ts sync all` | Request a full sync. |
-| `node src/cli.ts sync status` | Inspect local pending counts and sync state; no hub network request or credentials required. |
+| `node dist/cli.js sync` | Manually sync the recent window (24 hours by default). |
+| `node dist/cli.js sync all` | Request a full sync. |
+| `node dist/cli.js sync status` | Inspect local pending counts and sync state; no hub network request or credentials required. |
 
 Optional environment settings:
 

package/commands/doctor.md

@@ -6,4 +6,4 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI doctor command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" doctor
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" doctor

package/commands/report.md

@@ -6,4 +6,4 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI report command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" report
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" report

package/commands/setup.md

@@ -9,4 +9,4 @@ Then tell the user, briefly: paste the printed `statusLine` block into their
 because a Claude Code plugin cannot set `statusLine` for itself — the
 statusline is the only documented source of per-session cost.
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" setup
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" setup

package/commands/status.md

@@ -6,4 +6,4 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI status command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" status
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" status

package/commands/sync-all.md

@@ -6,4 +6,4 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI sync all command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" sync all
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" sync all

package/commands/sync-status.md

@@ -6,4 +6,4 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI sync status command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" sync status
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" sync status

package/commands/sync.md

@@ -6,9 +6,9 @@ allowed-tools: Bash(node:*)
 Run the kankaku CLI sync command and show its output to the user verbatim,
 inside a code block, with no summarizing or reformatting:
 
-!node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" sync
+!node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" sync
 
 For a full sync or local sync status, use the direct CLI instead:
-`node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" sync all` or
-`node "${CLAUDE_PLUGIN_ROOT}/src/cli.ts" sync status`.
+`node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" sync all` or
+`node "${CLAUDE_PLUGIN_ROOT}/dist/cli.js" sync status`.
 This slash command runs the default sync only; it does not forward arguments.

package/dist/auto-sync.js

@@ -0,0 +1,28 @@
+/** Best-effort heavy-hook sync; credential/transport errors never escape into record handling. */
+export async function autoSync(trigger, deps) {
+    if (deps.env.KANKAKU_SYNC_AUTO === "0")
+        return;
+    try {
+        const { resolveHubCredentials } = await import("kankaku/hub");
+        const { homedir } = await import("node:os");
+        const hub = resolveHubCredentials({ env: deps.env, homeDir: deps.homeDir ?? (() => deps.env.HOME || homedir()) });
+        if (!hub.credentials || hub.invalidReason)
+            return;
+        const { syncConfigured } = await import("./sync-cli.js");
+        // One deadline across catalog and upload requests; the public client also
+        // imposes its own per-request timeout. No timer persists after the hook.
+        const deadline = AbortSignal.timeout(8_000);
+        const doFetch = deps.fetch ?? fetch;
+        const boundedFetch = (input, init) => doFetch(input, {
+            ...init,
+            signal: init?.signal ? AbortSignal.any([init.signal, deadline]) : deadline,
+        });
+        const result = await syncConfigured({ ...deps, fetch: boundedFetch }, hub.credentials, { trigger });
+        if (result.error || result.failed.length) {
+            deps.stderr(`kankaku auto-sync: ${result.error ?? result.failed.map((f) => f.reason).join("; ")}`);
+        }
+    }
+    catch (error) {
+        deps.stderr(`kankaku auto-sync: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/claude-pid.js

@@ -0,0 +1,61 @@
+import { execFileSync } from "node:child_process";
+import { basename } from "node:path";
+const SKIP_COMMS = new Set(["sh", "bash", "zsh", "dash", "fish", "node"]);
+const MAX_HOPS = 6;
+/**
+ * Walks ancestors from `startPid` (at most `MAX_HOPS` hops), returning the
+ * first pid whose `comm` basename is not a shell or `node` — the Claude
+ * Code process itself, skipping the shell/node layers a hook can be
+ * launched through. Falls back to `startPid` when `ps` fails or nothing
+ * qualifies within the hop budget.
+ */
+export function resolveClaudePid({ startPid, runPs }) {
+    let pid = startPid;
+    for (let hop = 0; hop < MAX_HOPS; hop++) {
+        const info = runPs(pid);
+        if (!info)
+            return startPid;
+        if (!SKIP_COMMS.has(basename(info.comm)))
+            return pid;
+        pid = info.ppid;
+    }
+    return startPid;
+}
+/** Production `runPs`: `ps -o ppid=,comm= -p <pid>`, bounded to 200ms. */
+export function runPsProcess(pid) {
+    try {
+        const out = execFileSync("ps", ["-o", "ppid=,comm=", "-p", String(pid)], {
+            timeout: 200,
+            encoding: "utf8",
+        });
+        const match = out.trim().match(/^(\d+)\s+(.+)$/);
+        if (!match)
+            return undefined;
+        const ppid = Number(match[1]);
+        const comm = match[2]?.trim();
+        if (!Number.isFinite(ppid) || !comm)
+            return undefined;
+        return { ppid, comm };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * `true` unless `process.kill(pid, 0)` throws with a code other than
+ * `EPERM`. A non-positive or non-integer pid is always `false`, without
+ * calling `process.kill` at all: `pid` 0 signals the whole process GROUP
+ * (T7 — the defect that let a placeholder state file's `pid: 0` read back
+ * as alive forever).
+ */
+export function isAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}

package/dist/cli-core.js

@@ -0,0 +1,75 @@
+import { basename, join } from "node:path";
+import { JsonlWorkLog } from "kankaku/hub";
+import { listStateFiles, resolveKankakuDir } from "./paths.js";
+import { readState } from "./session-state.js";
+import { readCost } from "./cost-store.js";
+import { formatReport } from "./report.js";
+import { runSyncCli } from "./sync-cli.js";
+import { runDoctor } from "./doctor.js";
+const USAGE = "usage: node dist/cli.js <report|status|setup|sync|doctor> [--days N]\n";
+/** CLI commands, resolved from `deps.cwd`. */
+export async function runCli(argv, deps) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case "report":
+            return runReport(rest, deps);
+        case "status":
+            return runStatus(deps);
+        case "setup":
+            return runSetup(deps);
+        case "sync":
+            return runSyncCli(rest, deps);
+        case "doctor":
+            return { stdout: runDoctor(deps), exitCode: 0 };
+        default:
+            return { stdout: "", exitCode: 1, stderr: USAGE };
+    }
+}
+function runReport(args, deps) {
+    const days = parseDays(args);
+    const kankakuDir = resolveKankakuDir(deps.env.KANKAKU_DIR ?? ".kankaku", deps.cwd);
+    const records = new JsonlWorkLog(kankakuDir).readAll();
+    const stdout = formatReport(records, { now: deps.now(), ...(days !== undefined ? { days } : {}) });
+    return { stdout, exitCode: 0 };
+}
+function parseDays(args) {
+    const idx = args.indexOf("--days");
+    if (idx === -1)
+        return undefined;
+    const value = Number(args[idx + 1]);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function runStatus(deps) {
+    const kankakuDir = resolveKankakuDir(deps.env.KANKAKU_DIR ?? ".kankaku", deps.cwd);
+    const claudeDir = join(kankakuDir, "claude");
+    const files = listStateFiles(claudeDir);
+    if (files.length === 0) {
+        return { stdout: "No active sessions.\n", exitCode: 0 };
+    }
+    const lines = files
+        .sort()
+        .map((file) => formatStatusLine(sessionIdFromStateFile(file), file, deps.isAlive, deps.env));
+    return { stdout: lines.join("\n") + "\n", exitCode: 0 };
+}
+function formatStatusLine(sessionId, stateFile, isAlive, env) {
+    const state = readState(stateFile);
+    if (!state)
+        return `${sessionId}  (unreadable state)`;
+    const aliveWord = isAlive(state.pid) ? "alive" : "dead";
+    const promptWord = state.promptOpen
+        ? `prompt open since ${new Date(state.promptOpen.startedAt).toISOString()}`
+        : "idle";
+    const cost = readCost(env, sessionId);
+    const costWord = cost ? `$${cost.totalUsd.toFixed(2)}` : "-";
+    return `${sessionId}  pid ${state.pid} (${aliveWord})  ${promptWord}  cost ${costWord}`;
+}
+function sessionIdFromStateFile(file) {
+    return basename(file).replace(/\.state\.json$/, "");
+}
+function runSetup(deps) {
+    const statuslinePath = join(deps.pluginRoot, "dist", "statusline.js");
+    const command = `node "${statuslinePath}"`;
+    const snippet = JSON.stringify({ statusLine: { type: "command", command } }, null, 2);
+    const explanation = "Claude Code plugins cannot set statusLine themselves, so this must be added to ~/.claude/settings.json manually: the statusline is the only documented source of per-session cost.";
+    return { stdout: `${snippet}\n\n${explanation}\n`, exitCode: 0 };
+}

package/{src/cli.ts → dist/cli.js}

@@ -1,19 +1,18 @@
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
-import { runCli } from "./cli-core.ts";
-import { isAlive } from "./claude-pid.ts";
-
+import { runCli } from "./cli-core.js";
+import { isAlive } from "./claude-pid.js";
 // src/cli.ts -> src -> repo root (the directory that contains .claude-plugin/).
 const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-
 const result = await runCli(process.argv.slice(2), {
-  env: process.env,
-  cwd: process.cwd(),
-  now: () => Date.now(),
-  isAlive,
-  pluginRoot,
+    env: process.env,
+    cwd: process.cwd(),
+    now: () => Date.now(),
+    isAlive,
+    pluginRoot,
 });
-
-if (result.stdout) process.stdout.write(result.stdout);
-if (result.stderr) process.stderr.write(result.stderr);
+if (result.stdout)
+    process.stdout.write(result.stdout);
+if (result.stderr)
+    process.stderr.write(result.stderr);
 process.exit(result.exitCode);

package/dist/cost-store.js

@@ -0,0 +1,121 @@
+import { chmodSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Cost lives under the HOME directory, never a project: the statusline
+ * command is wired globally and runs in every session on the machine, so a
+ * project-relative path would litter whatever project happens to be open
+ * (the defect this module fixes — see `odd/tasks/hook-tracking.md` T7).
+ * Imports only node builtins so light hooks that read/write cost stay off
+ * the `kankaku` import path.
+ */
+export function costDir(env) {
+    const home = env.HOME || homedir();
+    return join(home, ".kankaku", "claude", "cost");
+}
+export function costFile(env, sessionId) {
+    return join(costDir(env), `${sessionId}.json`);
+}
+function isCostState(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const o = value;
+    return (typeof o.totalUsd === "number" &&
+        typeof o.updatedAt === "number" &&
+        (o.model === undefined || typeof o.model === "string"));
+}
+/** `undefined` when the file is absent or its contents are malformed. */
+export function readCost(env, sessionId) {
+    let text;
+    try {
+        text = readFileSync(costFile(env, sessionId), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    return isCostState(parsed) ? parsed : undefined;
+}
+/**
+ * Atomic tmp+rename write. Creates `claude/` and `claude/cost/` (both owned
+ * exclusively by this plugin) as owner-only (`0700`) when it creates them —
+ * `mkdirSync`'s `mode` only ever applies to a directory the call actually
+ * creates, so an existing `~/.kankaku` is never chmod'd by this. The written
+ * file is chmod'd `0600` best-effort. Never lowers `updatedAt`: a statusline
+ * write racing an older one loses.
+ */
+export function writeCost(env, sessionId, cost) {
+    const dir = costDir(env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const existing = readCost(env, sessionId);
+    if (existing && existing.updatedAt > cost.updatedAt)
+        return;
+    const file = costFile(env, sessionId);
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(cost));
+    renameSync(tmp, file);
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // best-effort
+    }
+}
+export function deleteCost(env, sessionId) {
+    try {
+        unlinkSync(costFile(env, sessionId));
+    }
+    catch {
+        // already gone
+    }
+}
+/**
+ * Deletes cost files whose `updatedAt` (or mtime, when the file is
+ * unparsable) is older than `maxAgeMs` (default 7 days). No-op when the
+ * cost directory does not exist yet.
+ */
+export function sweepStaleCostFiles(env, opts) {
+    const maxAgeMs = opts.maxAgeMs ?? SEVEN_DAYS_MS;
+    const dir = costDir(env);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (!name.endsWith(".json"))
+            continue;
+        const file = join(dir, name);
+        const sessionId = name.slice(0, -".json".length);
+        const cost = readCost(env, sessionId);
+        let age;
+        if (cost) {
+            age = opts.now - cost.updatedAt;
+        }
+        else {
+            try {
+                age = opts.now - statSync(file).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (age > maxAgeMs) {
+            try {
+                unlinkSync(file);
+            }
+            catch {
+                // already gone
+            }
+        }
+    }
+}