kankaku-claude 0.10.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.10.0",
+  "version": "0.11.0",
   "author": {
     "name": "soyunninja"
   },

package/CHANGELOG.md

@@ -4,6 +4,46 @@ 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.11.0 — 2026-09-29
+
+### Added
+
+- **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`.
+
 ## 0.10.0 — 2026-09-28
 
 ### Fixed

package/README.md

@@ -25,6 +25,13 @@ 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.
@@ -58,8 +65,7 @@ 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
+**Manual/dev: `--plugin-dir`.** Clone this repository, build it once, then point Claude Code
 at it directly:
 
 ```bash
@@ -79,10 +85,10 @@ 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. `--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.
+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
@@ -127,11 +133,15 @@ 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 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 dist/cli.js 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 dist/cli.js setup`).
 - `/kankaku:sync` — manually syncs recent local work records to the hub
@@ -186,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,
@@ -218,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/dist/cli-core.js

@@ -1,3 +1,4 @@
+import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { JsonlWorkLog } from "kankaku/hub";
 import { listStateFiles, resolveKankakuDir } from "./paths.js";
@@ -6,6 +7,7 @@ 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) {
@@ -43,13 +45,14 @@ 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: "No active sessions.\n", exitCode: 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: lines.join("\n") + "\n", exitCode: 0 };
+    return { stdout: [targetLine, ...lines].join("\n") + "\n", exitCode: 0 };
 }
 function formatStatusLine(sessionId, stateFile, isAlive, env) {
     const state = readState(stateFile);

package/dist/doctor.js

@@ -5,6 +5,7 @@ import { JsonlWorkLog, SyncStateStore, computeSyncStatus, resolveHubCredentials
 import { costDir } from "./cost-store.js";
 import { listStateFiles, resolveKankakuDir } from "./paths.js";
 import { readState } from "./session-state.js";
+import { formatTargetLine, resolveClaudeWorkTarget } from "./work-target.js";
 function metadata(file) {
     try {
         const value = JSON.parse(readFileSync(file, "utf8"));
@@ -88,6 +89,8 @@ export function runDoctor(deps) {
         `active sessions: ${states.length}`,
         `alive: ${alive}; dead: ${dead}; open prompts: ${open}; unreadable: ${unreadable}`,
         `cost files visible: ${costsVisible ? "yes" : "no"} (current HOME)`,
+        "", "## Work target",
+        formatTargetLine(resolveClaudeWorkTarget({ cwd: deps.cwd, kankakuDir: dir, homeDir: deps.env.HOME || homedir(), env: deps.env })),
         "", "## Hub / sync",
         `hub: ${hubState}`,
         `pending: ${pending}`,

package/dist/handle-hook.js

@@ -135,7 +135,8 @@ async function handleStop(paths, sessionId, deps) {
         : undefined;
     const core = replayPrompt(last, { cost: costDelta });
     if (core) {
-        const record = buildClaudeRecord(core, state, sessionId, cost?.model);
+        const assignment = await assignmentResolver(paths, deps);
+        const record = buildClaudeRecord(core, state, sessionId, cost?.model, assignment(state.cwd));
         const log = deps.log ?? new JsonlWorkLog(paths.kankakuDir);
         log.append(record);
     }
@@ -155,6 +156,7 @@ async function handleSessionStart(paths, sessionId, cwd, source, ts, deps) {
             isAlive: deps.isAlive,
             now: deps.now(),
             env: deps.env,
+            resolveAssignment: await assignmentResolver(paths, deps),
         });
         if (recovered.length > 0) {
             const log = deps.log ?? new JsonlWorkLog(paths.kankakuDir);
@@ -195,7 +197,8 @@ async function handleSessionEnd(paths, sessionId, cwd, ts, deps) {
             const core = replayPrompt(last, { settledAt: ts });
             if (core) {
                 const model = readCost(deps.env, sessionId)?.model;
-                const record = buildClaudeRecord(core, state, sessionId, model);
+                const assignment = await assignmentResolver(paths, deps);
+                const record = buildClaudeRecord(core, state, sessionId, model, assignment(state.cwd));
                 const log = deps.log ?? new JsonlWorkLog(paths.kankakuDir);
                 log.append(record);
             }
@@ -209,6 +212,39 @@ async function handleSessionEnd(paths, sessionId, cwd, ts, deps) {
         deleteCost(deps.env, sessionId);
     }
 }
+/**
+ * Loads the work-target resolver (a heavy module) and returns a per-cwd
+ * lookup that never throws: any failure means "no assignment", exactly the
+ * unassigned behaviour. Heavy hooks only.
+ */
+async function assignmentResolver(paths, deps) {
+    try {
+        const { resolveClaudeWorkTarget } = await import("./work-target.js");
+        const { homedir } = await import("node:os");
+        const resolve = deps.resolveTarget ?? resolveClaudeWorkTarget;
+        return (cwd) => {
+            try {
+                const { target, legacyClient } = resolve({
+                    cwd,
+                    kankakuDir: paths.kankakuDir,
+                    homeDir: deps.env.HOME || homedir(),
+                    env: deps.env,
+                });
+                return {
+                    ...(target !== undefined ? { target } : {}),
+                    ...(legacyClient !== undefined ? { legacyClient } : {}),
+                };
+            }
+            catch (error) {
+                deps.stderr(`kankaku: work target: ${error instanceof Error ? error.message : String(error)}`);
+                return {};
+            }
+        };
+    }
+    catch {
+        return () => ({});
+    }
+}
 async function syncHeavy(trigger, cwd, deps) {
     try {
         if (deps.autoSync)

package/dist/inflight-recovery.js

@@ -39,10 +39,15 @@ export function recoverStaleSessions(input) {
             const prompts = splitPrompts(events);
             const last = prompts[prompts.length - 1];
             if (last && last.open) {
-                const core = replayPrompt(last, { settledAt: input.now });
+                // Close at the prompt's last recorded activity, never at recovery
+                // time (which is the next session start, possibly hours later).
+                // `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 });
                 if (core) {
                     const model = readCost(input.env, sessionId)?.model;
-                    records.push(buildClaudeRecord(core, state, sessionId, model));
+                    records.push(buildClaudeRecord(core, state, sessionId, model, input.resolveAssignment?.(state.cwd)));
                 }
             }
         }

package/dist/record.js

@@ -1,12 +1,36 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** `version` from a `package.json`, or `undefined` when unreadable — never guessed. */
+export function readPackageVersion(file) {
+    try {
+        const pkg = JSON.parse(readFileSync(file, "utf8"));
+        return typeof pkg.version === "string" && pkg.version !== "" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Resolved once per hook process; `src/` and `dist/` share the same depth.
+const PLUGIN_VERSION = readPackageVersion(join(dirname(dirname(fileURLToPath(import.meta.url))), "package.json"));
 /**
  * Attaches the orchestrator metadata a replayed {@link WorkRecordCore}
- * needs to become a persistable {@link WorkRecord}. Phase 1: no
- * `client`/`clientId` (hub sync is phase 2). `model` is the statusline
+ * needs to become a persistable {@link WorkRecord}. `assignment` carries the
+ * resolved hub target (`clientId`, `clientName`, `projectId`, `projectName`)
+ * and the legacy `client` label, stamped exactly as the pi extension does;
+ * omitted, the record is unassigned. `model` is the statusline
  * model id (from `src/cost-store.ts#readCost`, since T7 no longer a field
  * of `SessionState`) — passed in explicitly rather than read here, so the
  * 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
+ * right identity. `agentVersion` is omitted: Claude Code passes its version
+ * to no hook payload, and spawning `claude --version` from a hook is not
+ * acceptable.
  */
-export function buildClaudeRecord(core, state, sessionId, model) {
+export function buildClaudeRecord(core, state, sessionId, model, assignment = {}) {
+    const { target, legacyClient } = assignment;
     return {
         ...core,
         role: "orchestrator",
@@ -15,6 +39,18 @@ export function buildClaudeRecord(core, state, sessionId, model) {
         project: state.cwd,
         sessionId,
         mode: "claude-code",
+        agent: "claude-code",
+        plugin: "kankaku-claude",
+        ...(PLUGIN_VERSION !== undefined ? { pluginVersion: PLUGIN_VERSION } : {}),
         ...(model ? { model: `anthropic/${model}` } : {}),
+        ...(legacyClient !== undefined ? { client: legacyClient } : {}),
+        ...(target !== undefined
+            ? {
+                clientId: target.clientId,
+                clientName: target.clientName,
+                ...(target.projectId !== undefined ? { projectId: target.projectId } : {}),
+                ...(target.projectName !== undefined ? { projectName: target.projectName } : {}),
+            }
+            : {}),
     };
 }

package/dist/work-target.js

@@ -0,0 +1,71 @@
+import { join } from "node:path";
+import { CachedCatalog, readProjectClient, readProjectTargetIds, resolveHubCredentials, } from "kankaku/hub";
+import { formatWorkTargetLabel, isValidClient, resolveClient, resolveWorkTarget, resolveWorkTargetSource, } from "kankaku/domain";
+/**
+ * Resolves the work target for a session, for record stamping and display.
+ *
+ * Sources, in order: the project's `config.json` ids, then the cached
+ * catalog's `repo_paths` match for `cwd`. The catalog comes only from the
+ * cache file that every real sync refreshes — there is no fetch, no refresh
+ * and no network here, and nothing throws: an unusable cache means "no
+ * target". The precedence and eligibility rules (active, not the
+ * "unassigned" client, project belongs to the client) live entirely in the
+ * library's `resolveWorkTarget`.
+ *
+ * Only the heavy hooks (Stop, SessionEnd, recovery) and the CLI call this;
+ * the per-tool-call hooks never do.
+ */
+export function resolveClaudeWorkTarget(input) {
+    try {
+        return resolveUnsafe(input);
+    }
+    catch {
+        return { reason: "no catalog cache" };
+    }
+}
+function resolveUnsafe(input) {
+    const projectClient = readProjectClient(input.kankakuDir);
+    const legacyFallback = resolveClient({ env: input.env.KANKAKU_CLIENT, project: projectClient });
+    const withLegacy = (result) => legacyFallback !== undefined ? { ...result, legacyClient: legacyFallback } : result;
+    const snapshot = readCatalogCache(input);
+    if (!snapshot)
+        return withLegacy({ reason: "no catalog cache" });
+    const resolveInput = {
+        project: readProjectTargetIds(input.kankakuDir),
+        cwd: input.cwd,
+        clients: snapshot.clients,
+        projects: snapshot.projects,
+    };
+    const target = resolveWorkTarget(resolveInput);
+    const source = resolveWorkTargetSource(resolveInput);
+    if (!target || (source !== "project" && source !== "repoPaths")) {
+        return withLegacy({ reason: `no match for ${input.cwd}` });
+    }
+    // Mirrors the pi extension: with a hub target the legacy label is the
+    // client's code, omitted when it is not a valid label.
+    return {
+        target,
+        source,
+        ...(isValidClient(target.clientCode) ? { legacyClient: target.clientCode } : {}),
+    };
+}
+function readCatalogCache(input) {
+    // The cache is keyed by hub url; the url comes from credentials (env or
+    // file), which are read locally. No credentials, no way to trust a cache.
+    const hub = resolveHubCredentials({ env: input.env, homeDir: () => input.homeDir });
+    if (!hub.credentials)
+        return undefined;
+    return new CachedCatalog({
+        filePath: join(input.homeDir, ".kankaku", "catalog.json"),
+        url: hub.credentials.url,
+        clock: { now: () => 0 }, // read() never consults the clock
+        fetchCatalog: () => Promise.reject(new Error("the hook path never fetches")),
+    }).read();
+}
+/** The `target:` line printed by `/kankaku:status` and `/kankaku:doctor`. */
+export function formatTargetLine(result) {
+    if (!result.target)
+        return `target: none (${result.reason ?? "unresolved"})`;
+    const source = result.source === "project" ? "project config" : "repo_paths";
+    return `target: ${formatWorkTargetLabel(result.target)} (source: ${source})`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kankaku-claude",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "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.10.0"
+    "kankaku": "^0.11.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.4",