kankaku-claude 0.9.0 → 0.11.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "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.9.0",
+  "version": "0.11.0",
   "author": {
     "name": "soyunninja"
   },

package/CHANGELOG.md

@@ -4,16 +4,75 @@ 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/).
 
-## 0.9.0 — 2026-09-28
+## 0.11.0 — 2026-09-29
 
-### Changed
+### Added
 
-- 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.
+- **Records resolve their client and project automatically.** Records
+  written at Stop, SessionEnd and crash recovery now carry `clientId`,
+  `clientName`, `projectId` and `projectName` (and the legacy `client`
+  label) when the project `config.json` ids or the cached catalog's
+  `repo_paths` match the session's working directory, so the hub no longer
+  files them under the unassigned client. The catalog is read from
+  `~/.kankaku/catalog.json` only: no network, no delay, and no target when
+  the cache is missing. Records already on disk are not rewritten, and rows
+  already uploaded as unassigned stay so until reassigned in the web app.
+- `/kankaku:status` and `/kankaku:doctor` print the resolved target and its
+  source, or `target: none (<reason>)`.
+
+## 0.10.2 — 2026-09-29
+
+### Fixed
+
+- **Records synced by another tool were attributed to the syncer.** Records
+  carried no `agent`/`plugin`, so when the kankaku TUI synced a worklog
+  written by Claude Code, the hub row was created as agent `unknown`,
+  plugin `kankaku-tui`. Every record (settled, settled at SessionEnd, or
+  recovered as `interrupted`) now carries `agent: "claude-code"`,
+  `plugin: "kankaku-claude"` and `pluginVersion`. Records already on disk
+  are not rewritten.
+
+## 0.10.1 — 2026-09-29
+
+### Fixed
+
+- **A prompt interrupted by a hung session was recorded with the time until
+  the next session started.** Crash recovery settled the open prompt at
+  recovery time, so a session that hung and was recovered the next morning
+  produced a record with a 14.4 h wall time. The prompt is now closed at
+  the timestamp of the last event recorded for it (its own
+  `UserPromptSubmit` when nothing followed); a waiting span still open is
+  closed at the same instant, and the record stays `interrupted`.
 
-## [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
 
@@ -71,3 +130,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

@@ -25,25 +25,76 @@ its own `worklog.jsonl`. This means kankaku's existing report and export
 tooling can read this plugin's worklog unchanged. kankaku-claude also exposes
 manual and best-effort automatic hub sync through kankaku's public hub adapters (below).
 
+Every record carries the identity of who measured it: `agent: "claude-code"`,
+`plugin: "kankaku-claude"` and `pluginVersion` (this package's version).
+A worklog synced by another tool, such as the kankaku TUI, therefore keeps
+the right agent on the hub. `agentVersion` is left unset because Claude Code
+does not pass its version to hooks. Records written before this version carry
+no identity and are labelled by whichever tool syncs them first.
+
 ## 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`.** 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. A plugin
+wired only through settings.json hooks does not register its commands, so
+`kankaku setup` installs the `/kankaku:*` commands separately (see
+"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:
 
@@ -61,7 +112,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
@@ -81,23 +133,27 @@ anything behind in whatever project happens to be open.
 
 ## Commands
 
+`kankaku setup` installs these as user commands under
+`~/.claude/commands/kankaku/`, so they work without `--plugin-dir`.
+
 - `/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, preceded by the resolved work
+  target (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).
@@ -114,9 +170,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:
 
@@ -140,6 +196,36 @@ window, and record settings above apply to both manual and automatic sync.
 Automatic runs use kankaku's change detection and per-prompt throttle; session
 boundaries are not throttled. Set `KANKAKU_SYNC_AUTO=0` to opt out.
 
+### Client and project assignment
+
+Each record is stamped with a hub client and project when one resolves, so
+the hub files the task under the right client instead of "Sin determinar".
+Sources, in order:
+
+1. the project's `<KANKAKU_DIR>/config.json` ids (`clientId`, optional
+   `projectId`);
+2. the cached catalog's `repo_paths`: the active project whose path equals
+   the session's working directory, or contains it.
+
+Inactive clients and projects, and the "unassigned" client, are never used.
+The catalog is read from the cache file `~/.kankaku/catalog.json` only; a
+hook never fetches it and never waits on the network. Every real sync
+refreshes that cache, and `kankaku catalog refresh` refreshes it on demand.
+Without a readable cache (or without hub credentials, which name the hub the
+cache belongs to) no target resolves and records stay unassigned, exactly as
+before. The legacy `client` label is the client's code when it is a valid
+label; without a hub target it comes from `KANKAKU_CLIENT`, then the
+`client` in `config.json`.
+
+The target is resolved when a record is written (`Stop`, `SessionEnd`,
+crash recovery), never on the per-tool-call hooks. `/kankaku:status` and
+`/kankaku:doctor` print `target: <client> · <project> (source: ...)`, or
+`target: none (<reason>)`.
+
+There is nothing to pick inside Claude Code yet. Assignment is create-only
+on the hub: a row already uploaded as unassigned stays that way until it is
+reassigned in the web app; a later sync does not move it.
+
 ## Where the files live
 
 - `<KANKAKU_DIR>/worklog.jsonl` — the append-only log of settled records,
@@ -172,6 +258,12 @@ and appended as one `status: "interrupted"` record before its files are
 deleted; a dead session with no open prompt just has its files deleted. This
 also runs for the current session's own leftover state at `SessionEnd`.
 
+An interrupted prompt is closed at its last recorded activity — the
+timestamp of the last event logged for it, or its own start when nothing
+followed — never at the moment of recovery, so a session that hung and was
+recovered hours later does not report those hours as work. A waiting span
+still open is closed at that same instant.
+
 ## Limitations
 
 - **`turns` is always 1 per run.** Claude Code hooks give no way to observe

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,78 @@
+import { homedir } from "node:os";
+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";
+import { formatTargetLine, resolveClaudeWorkTarget } from "./work-target.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);
+    const targetLine = formatTargetLine(resolveClaudeWorkTarget({ cwd: deps.cwd, kankakuDir, homeDir: deps.env.HOME || homedir(), env: deps.env }));
+    if (files.length === 0) {
+        return { stdout: `${targetLine}\nNo active sessions.\n`, exitCode: 0 };
+    }
+    const lines = files
+        .sort()
+        .map((file) => formatStatusLine(sessionIdFromStateFile(file), file, deps.isAlive, deps.env));
+    return { stdout: [targetLine, ...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);