kankaku-claude 0.12.1 → 1.0.1

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.12.1",
+  "version": "1.0.1",
   "author": {
     "name": "soyunninja"
   },

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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/).
 
+## 1.0.1 — 2026-09-29
+
+### Fixed
+
+- Spend that landed between two prompts was in no record: on a real session
+  the statusline total was 461.06 USD while its 134 records summed to
+  299.80 USD, so 35 % of the spend was missing. A prompt's cost was measured
+  from the statusline snapshot at submit, which left background subagent
+  work and late statusline refreshes after a `Stop` unattributed. The
+  session state now keeps `costBaseline`, the total at the last settle, and
+  each prompt is measured from it (Stop, SessionEnd and crash recovery), so
+  the records of a session add up to its total. A new session starts at 0; a
+  counter reset records the new total. `/kankaku:status` shows `recorded $X
+  of $Y` and flags an unrecorded gap. Headless runs still have no cost.
+
+## 1.0.0 — 2026-09-29
+
+### Changed
+
+- The library dependency is renamed from `kankaku` to `kankaku-pi`, and
+  its entry points are imported as `kankaku-pi/domain`, `kankaku-pi/ports`
+  and `kankaku-pi/hub`. The package keeps its own name, `kankaku-claude`
+  (directory unchanged). No behaviour change.
+- `kankaku-claude sync` usage text names `dist/cli.js`, and comments no
+  longer point at files that are not in the repository.
+
 ## 0.12.1 — 2026-09-29
 
 No changes in this package; released in lockstep with kankaku 0.12.1.

package/README.md

@@ -40,27 +40,27 @@ no identity and are labelled by whichever tool syncs them first.
   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
+  `.ts` source. Installed via `kankaku` (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
 
-**Recommended: `kankaku-tui`'s setup wizard.** This package lives inside
-`kankaku-tui`'s own dependency tree, so installing and running its setup
+**Recommended: `kankaku`'s setup wizard.** This package lives inside
+`kankaku`'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
+npm i -g kankaku
 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
+clobbering — whatever else is already there. See `kankaku`'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.
@@ -72,7 +72,7 @@ at it directly:
 git clone https://github.com/soyunninja/kankaku.git
 cd kankaku/packages/claude
 npm install && npm run build
-claude --plugin-dir /path/to/kankaku-claude
+claude --plugin-dir "$PWD"
 ```
 
 `npm run build` compiles `src/` into `dist/`; the hooks, statusline and
@@ -113,7 +113,7 @@ 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. `kankaku setup` (above)
-writes it for you automatically; without `kankaku-tui`, run:
+writes it for you automatically; without `kankaku`, run:
 
 ```
 /kankaku:setup
@@ -140,8 +140,11 @@ anything behind in whatever project happens to be open.
   `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, preceded by the resolved work
-  target (wraps `node dist/cli.js status`).
+  and the last cost the statusline reported, followed by `recorded $X of
+  $Y` (the sum of this session's record costs in this project's worklog
+  against the session total). When the two differ by more than a cent and no
+  prompt is open, the line adds `(unrecorded $Z, goes to the next prompt)`.
+  The resolved work target comes first (wraps `node dist/cli.js status`).
 - `/kankaku:task` — links this session to a hub task (wraps
   `node dist/cli.js task`); see "Linking a task" below.
 - `/kankaku:setup` — prints the `statusLine` snippet described above (wraps
@@ -257,6 +260,37 @@ from Claude Code is not supported 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.
 
+## How cost is derived
+
+Claude Code hooks carry no cost. The only source is the statusline, whose
+`cost.total_cost_usd` is the running total of the session; the statusline
+command stores the latest value under your home directory (see "Where the
+files live").
+
+- **Per-prompt difference.** A prompt's cost is the session total when the
+  prompt settles minus the total the prompt is measured from, rounded to
+  micro-dollars and never negative.
+- **Chained baseline.** The session state keeps `costBaseline`, the session
+  total at the last settle. The next prompt is measured from that baseline,
+  not from the snapshot at submit, so the records of a session add up to its
+  total. A session Claude Code reports as newly started (`SessionStart`
+  source `startup`) begins with baseline 0. A resumed session keeps the
+  baseline of its state file; with no state file its first prompt is
+  measured from the snapshot at submit.
+- **Spend between prompts belongs to the next record.** `worklog.jsonl` is
+  append-only and the previous record is already written, so anything spent
+  after a settle and before the next prompt (background subagents that keep
+  running, a statusline refresh that arrives after `Stop`) is added to the
+  next record of the same session.
+- **Counter reset.** If the total is lower than the value the prompt is
+  measured from, the counter was reset: the prompt's cost is the new total
+  and the baseline restarts from it.
+- **Headless runs have no cost.** `claude -p` renders no statusline, so
+  there is no total: the record stays without cost (`costObserved` unset)
+  and the baseline does not move.
+- `/kankaku:status` shows `recorded $X of $Y` per live session so a gap is
+  visible.
+
 ## Where the files live
 
 - `<KANKAKU_DIR>/worklog.jsonl` — the append-only log of settled records,
@@ -304,9 +338,11 @@ still open is closed at that same instant.
   only the statusline's aggregate `total_cost_usd`; per-record `usage` token
   fields stay at zero, cost is the only populated figure.
 - **Cost is a per-prompt delta of the session total, from the statusline,
-  and needs the manual setup step.** A tiny race is possible: the statusline
-  can render after `Stop` has already computed the delta, in which case a
-  sliver of one prompt's cost is attributed to the next prompt instead.
+  and needs the manual setup step.** See "How cost is derived". Spend that
+  lands between two prompts (a late statusline refresh, a background
+  subagent still running) is attributed to the next record of the session,
+  not lost. Headless `claude -p` runs have no statusline, so their records
+  carry no cost.
 - **A permission wait ends at the next hook event, not when you actually
   click.** There is no documented hook that fires the moment you answer a
   permission dialog, so the waiting span closes at whatever hook fires next

package/dist/auto-sync.js

@@ -3,7 +3,7 @@ export async function autoSync(trigger, deps) {
     if (deps.env.KANKAKU_SYNC_AUTO === "0")
         return;
     try {
-        const { resolveHubCredentials } = await import("kankaku/hub");
+        const { resolveHubCredentials } = await import("kankaku-pi/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)

package/dist/cli-core.js

@@ -1,5 +1,5 @@
 import { basename, join } from "node:path";
-import { JsonlWorkLog } from "kankaku/hub";
+import { JsonlWorkLog } from "kankaku-pi/hub";
 import { listStateFiles, resolveKankakuDir } from "./paths.js";
 import { readState } from "./session-state.js";
 import { readCost } from "./cost-store.js";
@@ -52,12 +52,21 @@ function runStatus(deps) {
     if (files.length === 0) {
         return { stdout: `${targetLine}\nNo active sessions.\n`, exitCode: 0 };
     }
+    const recordedBySession = new Map();
+    for (const record of new JsonlWorkLog(kankakuDir).readAll()) {
+        if (record.sessionId === undefined)
+            continue;
+        recordedBySession.set(record.sessionId, (recordedBySession.get(record.sessionId) ?? 0) + record.usage.cost);
+    }
     const lines = files
         .sort()
-        .map((file) => formatStatusLine(sessionIdFromStateFile(file), file, deps.isAlive, deps.env));
+        .map((file) => {
+        const sessionId = sessionIdFromStateFile(file);
+        return formatStatusLine(sessionId, file, deps.isAlive, deps.env, recordedBySession.get(sessionId) ?? 0);
+    });
     return { stdout: [targetLine, ...lines].join("\n") + "\n", exitCode: 0 };
 }
-function formatStatusLine(sessionId, stateFile, isAlive, env) {
+function formatStatusLine(sessionId, stateFile, isAlive, env, recordedUsd) {
     const state = readState(stateFile);
     if (!state)
         return `${sessionId}  (unreadable state)`;
@@ -67,7 +76,12 @@ function formatStatusLine(sessionId, stateFile, isAlive, env) {
         : "idle";
     const cost = readCost(env, sessionId);
     const costWord = cost ? `$${cost.totalUsd.toFixed(2)}` : "-";
-    return `${sessionId}  pid ${state.pid} (${aliveWord})  ${promptWord}  cost ${costWord}`;
+    const base = `${sessionId}  pid ${state.pid} (${aliveWord})  ${promptWord}  cost ${costWord}`;
+    if (!cost)
+        return base;
+    const gap = cost.totalUsd - recordedUsd;
+    const warning = gap > 0.01 && !state.promptOpen ? ` (unrecorded $${gap.toFixed(2)}, goes to the next prompt)` : "";
+    return `${base}  recorded $${recordedUsd.toFixed(2)} of $${cost.totalUsd.toFixed(2)}${warning}`;
 }
 function sessionIdFromStateFile(file) {
     return basename(file).replace(/\.state\.json$/, "");

package/dist/cost-chain.js

@@ -0,0 +1,20 @@
+/**
+ * The chained per-prompt cost rule. `totalUsd` is the session total at
+ * settle, `start` the total the prompt is measured from (the previous
+ * settle's baseline, or the snapshot at submit for a session with none).
+ *
+ * - No finite total (headless, no statusline): nothing observed, baseline
+ *   untouched.
+ * - Total below the start: the counter was reset, so the cost is the total.
+ * - Otherwise cost = total - start, in micro-dollars (no binary float noise).
+ *
+ * Node builtins only; safe on the light hook path.
+ */
+export function settleCost(totalUsd, start) {
+    if (typeof totalUsd !== "number" || !Number.isFinite(totalUsd))
+        return {};
+    if (typeof start !== "number" || !Number.isFinite(start))
+        return { baseline: totalUsd };
+    const raw = totalUsd < start ? totalUsd : totalUsd - start;
+    return { cost: Math.max(0, Math.round(raw * 1e6) / 1e6), baseline: totalUsd };
+}

package/dist/cost-store.js

@@ -6,9 +6,10 @@ 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).
+ * (the defect this module fixes: cost files were written into whichever
+ * project happened to be open).
  * Imports only node builtins so light hooks that read/write cost stay off
- * the `kankaku` import path.
+ * the `kankaku-pi` import path.
  */
 export function costDir(env) {
     const home = env.HOME || homedir();

package/dist/doctor.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { JsonlWorkLog, SyncStateStore, computeSyncStatus, resolveHubCredentials } from "kankaku/hub";
+import { JsonlWorkLog, SyncStateStore, computeSyncStatus, resolveHubCredentials } from "kankaku-pi/hub";
 import { costDir } from "./cost-store.js";
 import { listStateFiles, resolveKankakuDir } from "./paths.js";
 import { readState } from "./session-state.js";

package/dist/handle-hook.js

@@ -5,12 +5,13 @@ import { readState, writeState, updateState } from "./session-state.js";
 import { resolveClaudePid } from "./claude-pid.js";
 import { splitPrompts } from "./prompts.js";
 import { readCost, deleteCost, sweepStaleCostFiles } from "./cost-store.js";
+import { settleCost } from "./cost-chain.js";
 const STOP_COST_WAIT_POLL_MS = 100;
 const STOP_COST_WAIT_MAX_MS = 1500;
 /**
  * Dispatches one Claude Code hook invocation. Light events (everything but
  * Stop/SessionStart/SessionEnd) only append one event line plus a tiny
- * state update, and never import `kankaku` at runtime — the heavier replay/
+ * state update, and never import `kankaku-pi` at runtime — the heavier replay/
  * storage layer is loaded with dynamic `import()` only inside the three
  * branches that actually settle or recover a record.
  */
@@ -31,14 +32,16 @@ export async function handleHook(input, deps) {
                 ? { ts, event: "UserPromptSubmit", prompt, promptId }
                 : { ts, event: "UserPromptSubmit", prompt };
             appendEvent(paths.eventsFile, event);
-            const costAtStart = readCost(deps.env, sessionId)?.totalUsd;
+            const snapshot = readCost(deps.env, sessionId)?.totalUsd;
             updateState(paths.stateFile, (state) => ({
                 pid: state?.pid ?? 0,
                 parentPid: state?.parentPid ?? 0,
                 cwd: state?.cwd || cwd,
                 startedAt: state?.startedAt ?? ts,
-                promptOpen: { id: promptId ?? `${sessionId}:${ts}`, startedAt: ts, costAtStart },
+                // The chained baseline wins over the snapshot: spend since the last settle belongs to this prompt.
+                promptOpen: { id: promptId ?? `${sessionId}:${ts}`, startedAt: ts, costAtStart: state?.costBaseline ?? snapshot },
                 permissionOpen: null,
+                ...(state?.costBaseline !== undefined ? { costBaseline: state.costBaseline } : {}),
             }));
             return;
         }
@@ -68,6 +71,7 @@ export async function handleHook(input, deps) {
                 startedAt: state?.startedAt ?? ts,
                 promptOpen: state?.promptOpen ?? null,
                 permissionOpen: ts,
+                ...(state?.costBaseline !== undefined ? { costBaseline: state.costBaseline } : {}),
             }));
             return;
         }
@@ -95,7 +99,7 @@ export async function handleHook(input, deps) {
         case "SessionStart": {
             const source = readString(raw.source) ?? "startup";
             appendEvent(paths.eventsFile, { ts, event: "SessionStart", source });
-            await handleSessionStart(paths, sessionId, cwd, source, ts, deps);
+            await handleSessionStart(paths, sessionId, cwd, source, raw.source === "startup", ts, deps);
             return;
         }
         case "SessionEnd": {
@@ -111,7 +115,7 @@ export async function handleHook(input, deps) {
 async function handleStop(paths, sessionId, deps) {
     const { replayPrompt } = await import("./replay.js");
     const { buildClaudeRecord } = await import("./record.js");
-    const { JsonlWorkLog } = await import("kankaku/hub");
+    const { JsonlWorkLog } = await import("kankaku-pi/hub");
     const events = readEventLog(paths.eventsFile);
     const beforeStopTs = events.length >= 2 ? events[events.length - 2].ts : events[events.length - 1]?.ts ?? deps.now();
     const deadline = deps.now() + STOP_COST_WAIT_MAX_MS;
@@ -128,28 +132,30 @@ async function handleStop(paths, sessionId, deps) {
             deps.stderr(`kankaku: no session state at Stop for ${sessionId}`);
         return;
     }
-    const costAtStart = state.promptOpen?.costAtStart;
-    const totalUsd = cost?.totalUsd;
-    const costDelta = typeof costAtStart === "number" && typeof totalUsd === "number"
-        ? Math.max(0, Math.round((totalUsd - costAtStart) * 1e6) / 1e6) // micro-dollars: no binary float noise in the record
-        : undefined;
-    const core = replayPrompt(last, { cost: costDelta });
+    // A Stop with no open prompt settles nothing: no cost, no baseline move.
+    const settled = state.promptOpen ? settleCost(cost?.totalUsd, state.promptOpen.costAtStart) : {};
+    const core = replayPrompt(last, { cost: settled.cost });
     if (core) {
         const assignment = await assignmentResolver(paths, deps);
         const record = buildClaudeRecord(core, state, sessionId, cost?.model, assignment(state.cwd, sessionId));
         const log = deps.log ?? new JsonlWorkLog(paths.kankakuDir);
         log.append(record);
     }
-    writeState(paths.stateFile, { ...state, promptOpen: null, permissionOpen: null });
+    writeState(paths.stateFile, {
+        ...state,
+        promptOpen: null,
+        permissionOpen: null,
+        ...(settled.baseline !== undefined ? { costBaseline: settled.baseline } : {}),
+    });
     const keep = events.slice(0, events.length - last.events.length);
     dropSettledPrompts(paths.eventsFile, keep);
     if (core)
         await syncHeavy("agent_settled", state.cwd, deps);
 }
-async function handleSessionStart(paths, sessionId, cwd, source, ts, deps) {
+async function handleSessionStart(paths, sessionId, cwd, source, isStartup, ts, deps) {
     if (source !== "compact") {
         const { recoverStaleSessions } = await import("./inflight-recovery.js");
-        const { JsonlWorkLog } = await import("kankaku/hub");
+        const { JsonlWorkLog } = await import("kankaku-pi/hub");
         const recovered = recoverStaleSessions({
             claudeDir: paths.claudeDir,
             currentSessionId: sessionId,
@@ -180,6 +186,8 @@ async function handleSessionStart(paths, sessionId, cwd, source, ts, deps) {
         startedAt: ts,
         promptOpen: null,
         permissionOpen: null,
+        // A newly started session's counter starts at zero; any other source keeps the snapshot-at-submit fallback.
+        ...(isStartup ? { costBaseline: 0 } : {}),
     };
     writeState(paths.stateFile, state);
     await syncHeavy("session_start", cwd, deps);
@@ -189,14 +197,16 @@ async function handleSessionEnd(paths, sessionId, cwd, ts, deps) {
     if (state?.promptOpen) {
         const { replayPrompt } = await import("./replay.js");
         const { buildClaudeRecord } = await import("./record.js");
-        const { JsonlWorkLog } = await import("kankaku/hub");
+        const { JsonlWorkLog } = await import("kankaku-pi/hub");
         const events = readEventLog(paths.eventsFile);
         const prompts = splitPrompts(events);
         const last = prompts[prompts.length - 1];
         if (last) {
-            const core = replayPrompt(last, { settledAt: ts });
+            const costNow = readCost(deps.env, sessionId);
+            const settled = settleCost(costNow?.totalUsd, state.promptOpen.costAtStart);
+            const core = replayPrompt(last, { settledAt: ts, cost: settled.cost });
             if (core) {
-                const model = readCost(deps.env, sessionId)?.model;
+                const model = costNow?.model;
                 const assignment = await assignmentResolver(paths, deps);
                 const record = buildClaudeRecord(core, state, sessionId, model, assignment(state.cwd, sessionId));
                 const log = deps.log ?? new JsonlWorkLog(paths.kankakuDir);

package/dist/inflight-recovery.js

@@ -6,6 +6,7 @@ import { readEventLog } from "./event-log.js";
 import { splitPrompts, replayPrompt } from "./replay.js";
 import { buildClaudeRecord } from "./record.js";
 import { readCost, deleteCost } from "./cost-store.js";
+import { settleCost } from "./cost-chain.js";
 /**
  * Crash recovery: for every other session's state file whose pid is dead,
  * replay its still-open prompt (if any) into an `interrupted` record, then
@@ -46,9 +47,10 @@ export function recoverStaleSessions(input) {
                 // `now` is only a fallback when no usable timestamp exists.
                 const lastTs = last.events[last.events.length - 1]?.ts;
                 const settledAt = typeof lastTs === "number" && Number.isFinite(lastTs) ? lastTs : input.now;
-                const core = replayPrompt(last, { settledAt });
+                const costNow = readCost(input.env, sessionId);
+                const core = replayPrompt(last, { settledAt, cost: settleCost(costNow?.totalUsd, state.promptOpen.costAtStart).cost });
                 if (core) {
-                    const model = readCost(input.env, sessionId)?.model;
+                    const model = costNow?.model;
                     records.push(buildClaudeRecord(core, state, sessionId, model, input.resolveAssignment?.(state.cwd, sessionId)));
                 }
             }

package/dist/paths.js

@@ -1,7 +1,7 @@
 import { readdirSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 /**
- * Same rule as kankaku's `resolveKankakuDir` (kankaku/hub): an absolute
+ * Same rule as `resolveKankakuDir` in the `kankaku-pi` hub barrel (`kankaku-pi/hub`): an absolute
  * `KANKAKU_DIR` is used as-is, a relative one is joined against the session's
  * cwd. Inlined rather than imported so the light hooks (one per tool call)
  * never load the hub barrel for a two-line helper.

package/dist/record.js

@@ -24,7 +24,7 @@ const PLUGIN_VERSION = readPackageVersion(join(dirname(dirname(fileURLToPath(imp
  * caller decides which cost snapshot's model applies.
  *
  * Also stamps who MEASURED the record (`agent`, `plugin`, `pluginVersion`),
- * so a worklog later synced by another tool (the kankaku TUI) keeps the
+ * so a worklog later synced by another tool (the `kankaku` CLI) keeps the
  * right identity. `agentVersion` is omitted: Claude Code passes its version
  * to no hook payload, and spawning `claude --version` from a hook is not
  * acceptable.

package/dist/replay.js

@@ -1,11 +1,11 @@
-import { WorkTracker } from "kankaku/domain";
+import { WorkTracker } from "kankaku-pi/domain";
 /** Tool names whose span counts as waiting rather than working. */
 const INTERACTIVE_TOOLS = ["AskUserQuestion"];
 /**
  * The plugin's own subagent profile: Claude Code's `Agent`/`Task` tool
  * calls open a subagent span, read from `subagent_type`. No join key is
- * offered (`SubagentStart`/`SubagentStop` are recorded but not linked — see
- * odd/tasks/hook-tracking.md "Replay (pure)").
+ * offered (`SubagentStart`/`SubagentStop` are recorded but not linked, so a
+ * subagent span is closed by the replay itself).
  */
 const CLAUDE_CODE_SUBAGENT_PROFILE = {
     id: "claude-code",
@@ -97,5 +97,10 @@ export function replayPrompt(prompt, opts = {}) {
     if (terminalStopIndex >= 0)
         return settled;
     current = opts.settledAt ?? prompt.events[prompt.events.length - 1].ts;
-    return tracker.onShutdown();
+    const interrupted = tracker.onShutdown();
+    if (!interrupted || typeof opts.cost !== "number" || !Number.isFinite(opts.cost))
+        return interrupted;
+    // An interrupted prompt ends no turn, so the tracker saw no cost; stamp the
+    // measured delta without inventing a turn.
+    return { ...interrupted, usage: { ...interrupted.usage, cost: interrupted.usage.cost + opts.cost }, costObserved: true };
 }

package/dist/report.js

@@ -1,4 +1,4 @@
-import { buildTasks } from "kankaku/domain";
+import { buildTasks } from "kankaku-pi/domain";
 const STATUS_WORD = {
     completed: "done",
     interrupted: "interrupted",

package/dist/sync-cli.js

@@ -2,9 +2,9 @@ import { readFileSync } from "node:fs";
 import { homedir, hostname, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CachedCatalog, JsonlWorkLog, PocketBaseClient, PocketBaseSink, SyncStateStore, computeSyncStatus, createPocketBaseCatalogFetcher, resolveHubCredentials, runSync, safeHomeDir, } from "kankaku/hub";
+import { CachedCatalog, JsonlWorkLog, PocketBaseClient, PocketBaseSink, SyncStateStore, computeSyncStatus, createPocketBaseCatalogFetcher, resolveHubCredentials, runSync, safeHomeDir, } from "kankaku-pi/hub";
 import { resolveKankakuDir } from "./paths.js";
-const usage = "usage: node src/cli.ts sync [all|status]\n";
+const usage = "usage: node dist/cli.js sync [all|status]\n";
 function windowHours(env) {
     const value = Number(env.KANKAKU_SYNC_WINDOW_HOURS);
     return env.KANKAKU_SYNC_WINDOW_HOURS && Number.isFinite(value) && value > 0 ? value : 24;

package/dist/task-cli.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { CachedCatalog, PocketBaseClient, createPocketBaseCatalogFetcher, resolveHubCredentials } from "kankaku/hub";
+import { CachedCatalog, PocketBaseClient, createPocketBaseCatalogFetcher, resolveHubCredentials } from "kankaku-pi/hub";
 import { findSession } from "./find-session.js";
 import { resolveKankakuDir, resolveTargetFile } from "./paths.js";
 import { readSessionTarget, writeSessionTarget } from "./session-target-store.js";

package/dist/task-select.js

@@ -2,7 +2,7 @@
  * Pure task selection for `/kankaku:task`. Mirrors pi's picker
  * (`adapters/target-picker.ts#pickHubTask`): a task is pickable when its
  * status is not `done` (the hub's statuses are `open | doing | done`, see
- * `HubTask` in `kankaku/domain`) and it belongs to the resolved project.
+ * `HubTask` in `kankaku-pi/domain`) and it belongs to the resolved project.
  */
 export function isOpenTask(task) {
     return task.status !== "done";

package/dist/work-target.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { CachedCatalog, readProjectClient, readProjectTargetIds, resolveHubCredentials, } from "kankaku/hub";
-import { formatWorkTargetLabel, isValidClient, resolveClient, resolveWorkTarget, resolveWorkTargetSource, } from "kankaku/domain";
+import { CachedCatalog, readProjectClient, readProjectTargetIds, resolveHubCredentials, } from "kankaku-pi/hub";
+import { formatWorkTargetLabel, isValidClient, resolveClient, resolveWorkTarget, resolveWorkTargetSource, } from "kankaku-pi/domain";
 import { findSession } from "./find-session.js";
 import { resolveKankakuDir, resolveTargetFile } from "./paths.js";
 import { readSessionTarget } from "./session-target-store.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku-claude",
-  "version": "0.12.1",
+  "version": "1.0.1",
   "description": "Claude Code plugin that records how long the agent works on each user prompt, in kankaku's worklog format.",
   "type": "module",
   "files": [
@@ -27,7 +27,7 @@
     "prepublishOnly": "npm run check"
   },
   "dependencies": {
-    "kankaku": "^0.12.1"
+    "kankaku-pi": "^1.0.1"
   },
   "devDependencies": {
     "@types/node": "^24.13.4",