kankaku 0.6.0 → 0.7.0

package/src/adapters/pi-tracker.ts

@@ -3,7 +3,7 @@ import { isValidClient } from "../domain/client-label.ts";
 import { formatWorkTargetLabel } from "../domain/work-target.ts";
 import type { RegistryClassification } from "../domain/registry-health.ts";
 import type { SubagentProfile } from "../domain/subagent-profile.ts";
-import type { RejectedChildEnvMarker } from "../config.ts";
+import type { KankakuConfig, RejectedChildEnvMarker } from "../config.ts";
 import type { OrchestratorRef, WorkRecord, WorkRecordCore, WorkRole } from "../domain/work-record.ts";
 import type { WorkTracker } from "../domain/work-tracker.ts";
 import type { Catalog } from "../ports/catalog.ts";
@@ -13,8 +13,15 @@ import { createSessionClient } from "./session-client.ts";
 import { readNonDefaultSessionDir } from "./session-dir.ts";
 import type { SessionTarget } from "./session-target.ts";
 import { createStatusBar } from "./status-bar.ts";
-import { notifyError, registerKankakuCommand } from "./kankaku-command.ts";
-import type { SyncCommandDeps } from "./kankaku-command.ts";
+import { appendReportEntry, notifyError, registerKankakuCommand } from "./kankaku-command.ts";
+import type { KankakuCommandDeps, SyncCommandDeps } from "./kankaku-command.ts";
+import { openKankakuPanel } from "./panel/kankaku-panel.ts";
+import { createAboutScreen } from "./panel/screens/about.ts";
+import { createDoctorScreen } from "./panel/screens/doctor.ts";
+import { createExportScreen } from "./panel/screens/export.ts";
+import { createReportScreen } from "./panel/screens/report.ts";
+import { createSyncScreen } from "./panel/screens/sync.ts";
+import { createTargetScreen } from "./panel/screens/target.ts";
 import type { SyncTrigger } from "./sync-runner.ts";
 
 export type { KankakuReportData } from "./kankaku-command.ts";
@@ -174,11 +181,37 @@ export interface PiTrackerDeps {
    * real timer.
    */
   shutdownSyncTimeoutMs?: number;
+  /**
+   * The full active kankaku configuration (`config.ts#loadConfig`), for the
+   * panel's `about` screen (P3). Optional so every existing direct
+   * `createPiTracker` caller (e.g. `tests/pi-tracker.test.ts`) keeps
+   * working unchanged — falls back to {@link FALLBACK_ABOUT_CONFIG} (an
+   * empty configuration) when absent. `extension.ts` always supplies the
+   * real one.
+   */
+  config?: KankakuConfig;
+  /** This session's resolved kankaku directory (`adapters/kankaku-dir.ts#resolveKankakuDir`), for the `about` screen. */
+  kankakuDir?: string;
+  /** pi's version (`adapters/agent-info.ts#resolveAgentVersion`), for the `about` screen. */
+  agentVersion?: string;
+  /** kankaku's own version (`adapters/agent-info.ts#resolvePluginVersion`), for the `about` screen. */
+  pluginVersion?: string;
+  /** The hub (PocketBase) URL, when configured, for the `about` screen. */
+  hubUrl?: string;
 }
 
 /** Default for {@link PiTrackerDeps.shutdownSyncTimeoutMs}. */
 const DEFAULT_SHUTDOWN_SYNC_TIMEOUT_MS = 3000;
 
+/** {@link PiTrackerDeps.config}'s fallback for a caller that has not wired the real one yet. */
+const FALLBACK_ABOUT_CONFIG: KankakuConfig = {
+  dir: ".kankaku",
+  interactiveTools: [],
+  subagentProfiles: [],
+  segmentRules: [],
+  rejectedSubagentChildEnvMarkers: [],
+};
+
 /** Default `isAlive`: probe with signal 0 — no signal is sent, only existence/permission is checked. */
 function defaultIsAlive(pid: number): boolean {
   try {
@@ -252,10 +285,19 @@ export function createPiTracker(pi: ExtensionAPI, deps: PiTrackerDeps): void {
     resolveIdleClient: idleDisplayLabel,
   });
 
-  const kankakuCommand = registerKankakuCommand(pi, {
+  const refreshIdleStatus = (ctx: ExtensionContext) => statusBar.showIdle(ctx);
+
+  // Built as a named const (rather than inlined into `registerKankakuCommand`
+  // below) so `openPanel`'s doctor screen can reuse the exact same
+  // `KankakuCommandDeps` `buildDoctorLines` needs — the panel and
+  // `/kankaku doctor` can then never drift. Safe to reference `commandDeps`
+  // from within its own `openPanel` closure: the closure body only runs
+  // once `/kankaku` (no args) is actually invoked, long after this `const`
+  // has finished initializing.
+  const commandDeps: KankakuCommandDeps = {
     log,
     sessionClient,
-    refreshIdleStatus: (ctx) => statusBar.showIdle(ctx),
+    refreshIdleStatus,
     writeExportFile: deps.writeExportFile,
     sessionTarget: deps.sessionTarget,
     catalog: deps.catalog,
@@ -270,7 +312,67 @@ export function createPiTracker(pi: ExtensionAPI, deps: PiTrackerDeps): void {
     rejectedSubagentChildEnvMarkers: deps.rejectedSubagentChildEnvMarkers,
     workLogRouting: deps.workLogRouting,
     subagentProfiles: deps.subagentProfiles,
-  });
+    // The hub is configured exactly when a session target is wired (see
+    // PiTrackerDeps.sessionTarget's doc comment): the panel's root menu
+    // uses the same signal to decide whether to offer `sync` — `target`
+    // itself is offered either way, since the legacy `/kankaku client
+    // <name>` label lives on that same screen and works with no hub at
+    // all (see `domain/panel-model.ts#rootMenu`'s `target` row).
+    openPanel: (ctx) =>
+      openKankakuPanel(ctx, {
+        hubConfigured: deps.sessionTarget !== undefined,
+        screens: {
+          target: createTargetScreen({
+            pi,
+            ctx,
+            role,
+            sessionTarget: deps.sessionTarget,
+            sessionClient,
+            catalog: deps.catalog,
+            refreshIdleStatus,
+          }),
+          report: createReportScreen({
+            log,
+            ctx,
+            pi,
+            sessionId: () => ctx.sessionManager.getSessionId(),
+            pinReport: (report) => appendReportEntry(pi, ctx, report),
+          }),
+          doctor: createDoctorScreen({
+            commandDeps,
+            ctx,
+            pinReport: (report) => appendReportEntry(pi, ctx, report),
+          }),
+          about: createAboutScreen({
+            config: deps.config ?? FALLBACK_ABOUT_CONFIG,
+            kankakuDir: deps.kankakuDir ?? deps.config?.dir ?? FALLBACK_ABOUT_CONFIG.dir,
+            agentVersion: deps.agentVersion,
+            pluginVersion: deps.pluginVersion,
+            hubUrl: deps.hubUrl,
+          }),
+          // Present only when the hub is configured — mirrors `sync`'s own
+          // hub-only root-menu row (`domain/panel-model.ts#rootMenu`).
+          ...(deps.sync
+            ? {
+                sync: createSyncScreen({
+                  sync: deps.sync,
+                  catalog: deps.catalog,
+                  ctx,
+                  refreshIdleStatus,
+                  pinReport: (report) => appendReportEntry(pi, ctx, report),
+                }),
+              }
+            : {}),
+          export: createExportScreen({
+            log,
+            writeExportFile: deps.writeExportFile,
+            ctx,
+            pinReport: (report) => appendReportEntry(pi, ctx, report),
+          }),
+        },
+      }),
+  };
+  const kankakuCommand = registerKankakuCommand(pi, commandDeps);
 
   /** At most one quiet auto-sync failure notification per session; never notified on success. Shared by the fire-and-forget `triggerAutoSync` and the awaited shutdown sync below. */
   let autoSyncErrorNotified = false;
@@ -386,6 +488,8 @@ export function createPiTracker(pi: ExtensionAPI, deps: PiTrackerDeps): void {
             clientName: target.clientName,
             ...(target.projectId !== undefined ? { projectId: target.projectId } : {}),
             ...(target.projectName !== undefined ? { projectName: target.projectName } : {}),
+            ...(target.hubTaskId !== undefined ? { hubTaskId: target.hubTaskId } : {}),
+            ...(target.hubTaskTitle !== undefined ? { hubTaskTitle: target.hubTaskTitle } : {}),
           }
         : {}),
       ...(deps.machine !== undefined ? { machine: deps.machine } : {}),

package/src/adapters/pocketbase-catalog.ts

@@ -1,4 +1,4 @@
-import type { Client, Project } from "../domain/work-target.ts";
+import type { Client, HubTask, Project } from "../domain/work-target.ts";
 import type { PocketBaseClient, PocketBaseRecord } from "./pocketbase-client.ts";
 
 interface ClientRecord extends PocketBaseRecord {
@@ -16,6 +16,15 @@ interface ProjectRecord extends PocketBaseRecord {
   active?: boolean;
 }
 
+interface TaskRecord extends PocketBaseRecord {
+  title?: string;
+  project: string;
+  status?: string;
+  external_ref?: string;
+}
+
+const TASK_STATUSES = new Set(["open", "doing", "done"]);
+
 function mapClient(record: ClientRecord): Client {
   return {
     id: record.id,
@@ -37,24 +46,44 @@ function mapProject(record: ProjectRecord): Project {
   };
 }
 
+/** `open` on any unrecognised or missing status, rather than dropping the task. */
+function mapTaskStatus(status: string | undefined): HubTask["status"] {
+  return status !== undefined && TASK_STATUSES.has(status) ? (status as HubTask["status"]) : "open";
+}
+
+function mapTask(record: TaskRecord): HubTask {
+  return {
+    id: record.id,
+    title: record.title ?? "",
+    projectId: record.project,
+    status: mapTaskStatus(record.status),
+    ...(typeof record.external_ref === "string" && record.external_ref !== "" ? { externalRef: record.external_ref } : {}),
+  };
+}
+
 /**
  * Build the `fetchCatalog` function {@link CachedCatalog} (`cached-catalog.ts`)
- * needs, backed by a {@link PocketBaseClient}. Fetches every `clients` and
- * `projects` record (no `active` filter, so the domain resolver can tell
- * "deleted" from "inactive"; see `domain/work-target.ts`), sorted by name.
- * `signal`, when given, bounds both fetches (see
+ * needs, backed by a {@link PocketBaseClient}. Fetches every `clients`,
+ * `projects` and `tasks` record in parallel (no `active`/`status` filter,
+ * so the domain resolver can tell "deleted" from "inactive"/"done"; see
+ * `domain/work-target.ts`), clients/projects sorted by name and tasks by
+ * title. `signal`, when given, bounds every fetch (see
  * `pocketbase-client.ts#request`).
  */
-export function createPocketBaseCatalogFetcher(client: PocketBaseClient): (signal?: AbortSignal) => Promise<{ clients: Client[]; projects: Project[] }> {
+export function createPocketBaseCatalogFetcher(
+  client: PocketBaseClient,
+): (signal?: AbortSignal) => Promise<{ clients: Client[]; projects: Project[]; tasks: HubTask[] }> {
   return async (signal?: AbortSignal) => {
-    const [clientRecords, projectRecords] = await Promise.all([
+    const [clientRecords, projectRecords, taskRecords] = await Promise.all([
       client.list<ClientRecord>("clients", { sort: "name" }, signal),
       client.list<ProjectRecord>("projects", { sort: "name" }, signal),
+      client.list<TaskRecord>("tasks", { sort: "title" }, signal),
     ]);
 
     return {
       clients: clientRecords.map(mapClient),
       projects: projectRecords.map(mapProject),
+      tasks: taskRecords.map(mapTask),
     };
   };
 }

package/src/adapters/pocketbase-sink.ts

@@ -14,7 +14,7 @@
 import { buildTaskEntryCreatePayload, buildTaskEntryUpdatePayload, buildWorkRecordPayload, resolveTaskAssignment, taskWorkRecords } from "../domain/hub-entry.ts";
 import type { PromptPrivacyMode } from "../domain/hub-entry.ts";
 import type { TaskView } from "../domain/task-view.ts";
-import type { Client, Project } from "../domain/work-target.ts";
+import type { Client, HubTask, Project } from "../domain/work-target.ts";
 import type { PushOutcome, PushTaskResult, WorkSink } from "../ports/work-sink.ts";
 import type { PocketBaseClient, PocketBaseRecord } from "./pocketbase-client.ts";
 import { PocketBaseError } from "./pocketbase-client.ts";
@@ -24,6 +24,7 @@ export interface PocketBaseSinkDeps {
   /** Catalog snapshot to resolve assignment against; see `domain/hub-entry.ts#resolveTaskAssignment`. */
   clients: Client[];
   projects: Project[];
+  tasks: HubTask[];
   machine: string;
   promptMode: PromptPrivacyMode;
   /** Coding agent that produced these rows; see `domain/hub-entry.ts#HubEntryContext.agent`. Defaults to `"pi"`. */
@@ -105,10 +106,21 @@ export class PocketBaseSink implements WorkSink {
     return found.get(value);
   }
 
-  private get entryContext(): { clients: Client[]; projects: Project[]; machine: string; promptMode: PromptPrivacyMode; agent: string; agentVersion?: string; plugin: string; pluginVersion?: string } {
+  private get entryContext(): {
+    clients: Client[];
+    projects: Project[];
+    tasks: HubTask[];
+    machine: string;
+    promptMode: PromptPrivacyMode;
+    agent: string;
+    agentVersion?: string;
+    plugin: string;
+    pluginVersion?: string;
+  } {
     return {
       clients: this.deps.clients,
       projects: this.deps.projects,
+      tasks: this.deps.tasks,
       machine: this.deps.machine,
       promptMode: this.deps.promptMode,
       agent: this.deps.agent ?? "pi",
@@ -177,7 +189,7 @@ export class PocketBaseSink implements WorkSink {
   }
 
   private async pushOne(task: TaskView, existingId: string | undefined): Promise<PushOutcome> {
-    const assignment = resolveTaskAssignment(task, this.deps.clients, this.deps.projects);
+    const assignment = resolveTaskAssignment(task, this.deps.clients, this.deps.projects, this.deps.tasks);
     const pushAssignment = { unassigned: assignment.routedToUnassigned, ...(assignment.legacyClientLabel ? { legacyLabel: assignment.legacyClientLabel } : {}) };
 
     try {

package/src/adapters/report-views.ts

@@ -0,0 +1,98 @@
+/**
+ * The five `/kankaku` report views (summary/tasks/sessions/clients/
+ * projects), each as one pure `WorkRecord[] -> KankakuReportData` builder.
+ * Extracted from `kankaku-command.ts`'s subcommand handlers (see
+ * odd/tasks/kankaku-panel.md P3) so the `/kankaku` subcommands and the
+ * panel's report screen (`panel/screens/report.ts`) always compute the
+ * exact same lines — neither ever re-implements the other's logic.
+ */
+import { buildSessions, buildTasks } from "../domain/task-view.ts";
+import { exportRows, toCsv, toJson } from "../domain/export.ts";
+import type { WorkRecord } from "../domain/work-record.ts";
+import type { KankakuReportData } from "./kankaku-command.ts";
+import { countUncertain, formatClients, formatProjects, formatReport, formatSessions, formatTasks, localDay, summarize, summarizeByClient, summarizeByProject } from "./report.ts";
+
+/** Shared by every view except `buildTasksView`: `all` includes every day, otherwise only today's local day. */
+export interface ReportViewOptions {
+  all: boolean;
+}
+
+/** `buildTasksView`'s own options: `all` scopes to every session instead of local-day range (tasks are never day-filtered — see `kankaku-command.ts`'s original `tasks` handler). */
+export interface TasksViewOptions {
+  all: boolean;
+  sessionId: string | undefined;
+}
+
+/** The plain-text summary view (`/kankaku` with no view token): role/task totals, plus a one-line hint when uncertain records were excluded (SUBAGENT-REQ-017). */
+export function buildSummaryView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData {
+  const { all } = options;
+  const summary = summarize(records, { all });
+  const lines = formatReport(summary).split(" | ");
+  const uncertainCount = countUncertain(records, { all });
+  if (uncertainCount > 0) {
+    lines.push(`kankaku: ${uncertainCount} uncertain record(s) excluded from tasks — run /kankaku doctor`);
+  }
+  return { title: all ? "summary (all days)" : "summary (today)", lines };
+}
+
+/** `/kankaku clients [all]`: per-client totals. */
+export function buildClientsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData {
+  const { all } = options;
+  const today = localDay(new Date().toISOString());
+  const tasks = buildTasks(records).filter((task) => all || localDay(task.startedAt) === today);
+  return { title: all ? "clients (all days)" : "clients (today)", lines: formatClients(summarizeByClient(tasks)).split("\n") };
+}
+
+/** `/kankaku projects [all]`: per-project totals. */
+export function buildProjectsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData {
+  const { all } = options;
+  const today = localDay(new Date().toISOString());
+  const tasks = buildTasks(records).filter((task) => all || localDay(task.startedAt) === today);
+  return { title: all ? "projects (all days)" : "projects (today)", lines: formatProjects(summarizeByProject(tasks)).split("\n") };
+}
+
+/** `/kankaku sessions [all]`: per-session totals. */
+export function buildSessionsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData {
+  const { all } = options;
+  const today = localDay(new Date().toISOString());
+  const tasks = buildTasks(records).filter((task) => all || localDay(task.startedAt) === today);
+  return { title: all ? "sessions (all days)" : "sessions (today)", lines: formatSessions(buildSessions(tasks)).split("\n") };
+}
+
+/**
+ * `/kankaku tasks [all]`: one line per task. Unlike every other view, tasks
+ * are never restricted by local day — `all` (or a missing `sessionId`)
+ * instead scopes from "this session" to "every session".
+ */
+export function buildTasksView(records: WorkRecord[], options: TasksViewOptions): KankakuReportData {
+  const { all, sessionId } = options;
+  const scoped = all || !sessionId;
+  const tasks = buildTasks(records).filter((task) => scoped || task.sessionId === sessionId);
+  return { title: scoped ? "tasks (every session)" : "tasks (this session)", lines: formatTasks(tasks).split("\n") };
+}
+
+/** {@link buildExportContent}'s options: `format` picks csv/json, `all` includes every day instead of just today's local day (mirrors every other view except `buildTasksView`). */
+export interface ExportContentOptions {
+  format: "csv" | "json";
+  all: boolean;
+}
+
+/**
+ * `/kankaku export [csv|json] [all]`'s file content: the flat export rows
+ * for today's (or every) task, rendered as csv or json, with the file name
+ * `/kankaku export` and the panel's export screen (`panel/screens/
+ * export.ts`) both use. Extracted from `kankaku-command.ts`'s
+ * `handleExportCommand` (see odd/tasks/kankaku-panel.md P4) so the
+ * subcommand and the panel never drift. `rowCount` is exposed only for the
+ * subcommand's "wrote N row(s) to <path>" confirmation line — the panel's
+ * own confirmation is simpler ("wrote <path>").
+ */
+export function buildExportContent(records: WorkRecord[], options: ExportContentOptions): { name: string; content: string; rowCount: number } {
+  const { format, all } = options;
+  const today = localDay(new Date().toISOString());
+  const tasks = buildTasks(records).filter((task) => all || localDay(task.startedAt) === today);
+  const rows = exportRows(tasks);
+  const content = format === "json" ? toJson(rows) : toCsv(rows);
+  const name = `tasks-${all ? "all" : today}.${format}`;
+  return { name, content, rowCount: rows.length };
+}

package/src/adapters/report.ts

@@ -1,7 +1,7 @@
 import { buildTasks, uncertainRecords } from "../domain/task-view.ts";
 import type { SessionView, TaskView } from "../domain/task-view.ts";
 import { localDay } from "../domain/day.ts";
-import { finiteOrZero } from "../domain/work-record.ts";
+import { cacheHitRatio, finiteOrZero } from "../domain/work-record.ts";
 import type { WorkRecord, WorkRole } from "../domain/work-record.ts";
 
 export { localDay } from "../domain/day.ts";
@@ -13,6 +13,12 @@ export interface RoleTotals {
   count: number;
   /** Estimated cost in USD, as priced by pi's model table. */
   cost: number;
+  /** Prompt input tokens, summed across every record of this role. */
+  input: number;
+  /** Prompt-cache read tokens, summed across every record of this role. */
+  cacheRead: number;
+  /** Prompt-cache write tokens, summed across every record of this role. */
+  cacheWrite: number;
   /** Per-tag total milliseconds summed across every record of this role. */
   segments: Record<string, number>;
 }
@@ -23,6 +29,12 @@ export interface TaskTotals {
   workMs: number;
   /** Estimated cost in USD, orchestrator and subagents combined. */
   cost: number;
+  /** Prompt input tokens, orchestrator and subagents combined. */
+  input: number;
+  /** Prompt-cache read tokens, orchestrator and subagents combined. */
+  cacheRead: number;
+  /** Prompt-cache write tokens, orchestrator and subagents combined. */
+  cacheWrite: number;
   /** Per-tag total milliseconds summed across every task (orchestrator and subagents). */
   segments: Record<string, number>;
 }
@@ -39,7 +51,7 @@ export interface SummarizeOptions {
 const ROLES: WorkRole[] = ["orchestrator", "subagent"];
 
 function emptyTotals(): RoleTotals {
-  return { workMs: 0, waitingMs: 0, wallMs: 0, count: 0, cost: 0, segments: {} };
+  return { workMs: 0, waitingMs: 0, wallMs: 0, count: 0, cost: 0, input: 0, cacheRead: 0, cacheWrite: 0, segments: {} };
 }
 
 /**
@@ -67,7 +79,7 @@ export function summarize(records: WorkRecord[], options: SummarizeOptions): Sum
   const summary: Summary = {
     orchestrator: emptyTotals(),
     subagent: emptyTotals(),
-    tasks: { count: 0, wallMs: 0, workMs: 0, cost: 0, segments: {} },
+    tasks: { count: 0, wallMs: 0, workMs: 0, cost: 0, input: 0, cacheRead: 0, cacheWrite: 0, segments: {} },
   };
   // Accumulated in Maps (see `addSegments`) and only converted to the
   // returned plain objects at the very end, via `Object.fromEntries`.
@@ -82,6 +94,9 @@ export function summarize(records: WorkRecord[], options: SummarizeOptions): Sum
     totals.wallMs += record.wallMs;
     totals.count += 1;
     totals.cost += finiteOrZero(record.usage.cost);
+    totals.input += finiteOrZero(record.usage.input);
+    totals.cacheRead += finiteOrZero(record.usage.cacheRead);
+    totals.cacheWrite += finiteOrZero(record.usage.cacheWrite);
     addSegments(segmentsByRole[record.role], record.segments);
   }
 
@@ -91,6 +106,9 @@ export function summarize(records: WorkRecord[], options: SummarizeOptions): Sum
     summary.tasks.wallMs += task.wallMs;
     summary.tasks.workMs += task.workMs;
     summary.tasks.cost += task.usage.cost;
+    summary.tasks.input += finiteOrZero(task.usage.input);
+    summary.tasks.cacheRead += finiteOrZero(task.usage.cacheRead);
+    summary.tasks.cacheWrite += finiteOrZero(task.usage.cacheWrite);
     addSegments(taskSegments, task.segments);
   }
 
@@ -131,6 +149,12 @@ function formatTime(iso: string): string {
   return `${hours}:${minutes}`;
 }
 
+/** Render `cache hit NN%` (integer percent) for a usage totals triple, or `undefined` when the ratio is undefined (nothing recorded). */
+function formatCacheHit(usage: { input: number; cacheRead: number; cacheWrite: number }): string | undefined {
+  const ratio = cacheHitRatio(usage);
+  return ratio === undefined ? undefined : `cache hit ${Math.round(ratio * 100)}%`;
+}
+
 /** Render non-zero segment tags as `tag Xm00s` pairs, sorted alphabetically, joined by `, `. Undefined when none are non-zero. */
 function formatSegmentTags(segments: Record<string, number>): string | undefined {
   const tags = Object.keys(segments)
@@ -144,10 +168,14 @@ function formatSegmentTags(segments: Record<string, number>): string | undefined
 export function formatReport(summary: Summary): string {
   const lines = ROLES.map((role) => {
     const totals = summary[role];
-    return `${role}: work ${formatMinutes(totals.workMs)}, waiting ${formatMinutes(totals.waitingMs)}, ${totals.count} record(s), ${formatCost(totals.cost)}`;
+    const cacheHit = formatCacheHit(totals);
+    const cacheHitPart = cacheHit !== undefined ? `, ${cacheHit}` : "";
+    return `${role}: work ${formatMinutes(totals.workMs)}, waiting ${formatMinutes(totals.waitingMs)}, ${totals.count} record(s), ${formatCost(totals.cost)}${cacheHitPart}`;
   });
+  const tasksCacheHit = formatCacheHit(summary.tasks);
+  const tasksCacheHitPart = tasksCacheHit !== undefined ? `, ${tasksCacheHit}` : "";
   lines.push(
-    `tasks: ${summary.tasks.count}, wall ${formatMinutes(summary.tasks.wallMs)}, work ${formatMinutes(summary.tasks.workMs)}, ${formatCost(summary.tasks.cost)}`,
+    `tasks: ${summary.tasks.count}, wall ${formatMinutes(summary.tasks.wallMs)}, work ${formatMinutes(summary.tasks.workMs)}, ${formatCost(summary.tasks.cost)}${tasksCacheHitPart}`,
   );
   const segmentTags = formatSegmentTags(summary.tasks.segments);
   if (segmentTags !== undefined) {
@@ -173,7 +201,9 @@ export function formatTasks(tasks: TaskView[]): string {
       const segmentTags = formatSegmentTags(task.segments);
       const segmentPart = segmentTags !== undefined ? `  ${segmentTags}` : "";
       const clientPart = task.client !== undefined ? `  client:${task.client}` : "";
-      return `${formatTime(task.startedAt)}${clientPart}  wall ${formatMinutes(task.wallMs)}  work ${formatMinutes(task.workMs)}  ${formatCost(task.usage.cost)}${segmentPart}  subagents ${task.subagents.length}  ${prompt}`;
+      const cacheHit = formatCacheHit(task.usage);
+      const cacheHitPart = cacheHit !== undefined ? `  ${cacheHit}` : "";
+      return `${formatTime(task.startedAt)}${clientPart}  wall ${formatMinutes(task.wallMs)}  work ${formatMinutes(task.workMs)}  ${formatCost(task.usage.cost)}${cacheHitPart}${segmentPart}  subagents ${task.subagents.length}  ${prompt}`;
     })
     .join("\n");
 }
@@ -184,6 +214,12 @@ export interface ClientTotals {
   workMs: number;
   /** Estimated cost in USD, summed across this client's tasks. */
   cost: number;
+  /** Prompt input tokens, summed across this client's tasks. */
+  input: number;
+  /** Prompt-cache read tokens, summed across this client's tasks. */
+  cacheRead: number;
+  /** Prompt-cache write tokens, summed across this client's tasks. */
+  cacheWrite: number;
   count: number;
 }
 
@@ -201,11 +237,14 @@ export function summarizeByClient(tasks: TaskView[]): Map<string, ClientTotals>
   const totals = new Map<string, ClientTotals>();
   for (const task of tasks) {
     const key = task.client ?? NO_CLIENT;
-    const entry = totals.get(key) ?? { wallMs: 0, waitingMs: 0, workMs: 0, cost: 0, count: 0 };
+    const entry = totals.get(key) ?? { wallMs: 0, waitingMs: 0, workMs: 0, cost: 0, input: 0, cacheRead: 0, cacheWrite: 0, count: 0 };
     entry.wallMs += task.wallMs;
     entry.waitingMs += task.waitingMs;
     entry.workMs += task.workMs;
     entry.cost += finiteOrZero(task.usage.cost);
+    entry.input += finiteOrZero(task.usage.input);
+    entry.cacheRead += finiteOrZero(task.usage.cacheRead);
+    entry.cacheWrite += finiteOrZero(task.usage.cacheWrite);
     entry.count += 1;
     totals.set(key, entry);
   }
@@ -220,6 +259,12 @@ export interface ProjectTotals {
   workMs: number;
   /** Estimated cost in USD, summed across this project's tasks. */
   cost: number;
+  /** Prompt input tokens, summed across this project's tasks. */
+  input: number;
+  /** Prompt-cache read tokens, summed across this project's tasks. */
+  cacheRead: number;
+  /** Prompt-cache write tokens, summed across this project's tasks. */
+  cacheWrite: number;
   count: number;
 }
 
@@ -237,11 +282,14 @@ export function summarizeByProject(tasks: TaskView[]): Map<string, ProjectTotals
   for (const task of tasks) {
     const key = task.projectId ?? NO_PROJECT;
     const name = task.projectId !== undefined ? (task.projectName ?? task.projectId) : NO_PROJECT;
-    const entry = totals.get(key) ?? { name, wallMs: 0, waitingMs: 0, workMs: 0, cost: 0, count: 0 };
+    const entry = totals.get(key) ?? { name, wallMs: 0, waitingMs: 0, workMs: 0, cost: 0, input: 0, cacheRead: 0, cacheWrite: 0, count: 0 };
     entry.wallMs += task.wallMs;
     entry.waitingMs += task.waitingMs;
     entry.workMs += task.workMs;
     entry.cost += finiteOrZero(task.usage.cost);
+    entry.input += finiteOrZero(task.usage.input);
+    entry.cacheRead += finiteOrZero(task.usage.cacheRead);
+    entry.cacheWrite += finiteOrZero(task.usage.cacheWrite);
     entry.count += 1;
     totals.set(key, entry);
   }
@@ -253,10 +301,11 @@ export function formatProjects(totals: Map<string, ProjectTotals>): string {
   if (totals.size === 0) return "no projects";
   return Array.from(totals.values())
     .sort((a, b) => a.name.localeCompare(b.name))
-    .map(
-      (t) =>
-        `${t.name}  work ${formatMinutes(t.workMs)}  waiting ${formatMinutes(t.waitingMs)}  wall ${formatMinutes(t.wallMs)}  ${formatCost(t.cost)}  tasks ${t.count}`,
-    )
+    .map((t) => {
+      const cacheHit = formatCacheHit(t);
+      const cacheHitPart = cacheHit !== undefined ? `  ${cacheHit}` : "";
+      return `${t.name}  work ${formatMinutes(t.workMs)}  waiting ${formatMinutes(t.waitingMs)}  wall ${formatMinutes(t.wallMs)}  ${formatCost(t.cost)}${cacheHitPart}  tasks ${t.count}`;
+    })
     .join("\n");
 }
 
@@ -265,10 +314,11 @@ export function formatClients(totals: Map<string, ClientTotals>): string {
   if (totals.size === 0) return "no clients";
   return Array.from(totals.entries())
     .sort(([a], [b]) => a.localeCompare(b))
-    .map(
-      ([client, t]) =>
-        `${client}  work ${formatMinutes(t.workMs)}  waiting ${formatMinutes(t.waitingMs)}  wall ${formatMinutes(t.wallMs)}  ${formatCost(t.cost)}  tasks ${t.count}`,
-    )
+    .map(([client, t]) => {
+      const cacheHit = formatCacheHit(t);
+      const cacheHitPart = cacheHit !== undefined ? `  ${cacheHit}` : "";
+      return `${client}  work ${formatMinutes(t.workMs)}  waiting ${formatMinutes(t.waitingMs)}  wall ${formatMinutes(t.wallMs)}  ${formatCost(t.cost)}${cacheHitPart}  tasks ${t.count}`;
+    })
     .join("\n");
 }