kankaku 0.7.1 → 0.8.0

package/README.md

@@ -96,6 +96,10 @@ Each line in `worklog.jsonl` is one JSON object:
   "projectId": "pocketbase-record-id",
   "projectName": "Portal",
   "machine": "laptop",
+  "agent": "pi",
+  "agentVersion": "0.87.1",
+  "plugin": "kankaku",
+  "pluginVersion": "0.7.1",
   "prompt": "first 200 chars of the first prompt",
   "startedAt": "2026-09-10T16:00:00.000Z",
   "settledAt": "2026-09-10T16:04:10.000Z",
@@ -160,6 +164,19 @@ anything that wants to reconstruct the exact `pi --session-dir <dir>
 sent as `session_dir` on every sync (see "Hub (PocketBase)" > "Sync" >
 "Agent and measurement quality").
 
+`agent`, `agentVersion`, `plugin` and `pluginVersion` are optional and
+identify who *measured* this record, not who later syncs it: a worklog can
+be synced by a process that did not write it (a standalone `kankaku` TUI
+syncing pi's records; a session syncing a directory another agent also
+wrote to), so this identity travels with the record instead of being
+resolved fresh by whichever process happens to push it to the hub. For a
+record this package writes, `agent` is always `"pi"` and `plugin` is always
+`"kankaku"`; `agentVersion`/`pluginVersion` are included when known and
+omitted rather than guessed. Neither field bumps `WORK_RECORD_SCHEMA` — an
+older record without them stays valid and falls back to the syncing
+process's own identity on create only (see "Hub (PocketBase)" > "Sync" >
+"Agent and measurement quality").
+
 ## Task and session views
 
 Each `WorkRecord` still measures one pi process's own prompt-to-idle span.
@@ -1038,25 +1055,39 @@ in the web app, from the unassigned queue.
 **Agent and measurement quality.** Every `task_entries` row also carries
 who produced it and how well each figure was measured, so the hub can
 label what it has instead of silently blending incompatible numbers from
-different agents: `agent` (`"pi"`), `agent_version` (pi's own version,
-when it could be determined — never guessed, omitted otherwise), `plugin`
-(`"kankaku"`), `plugin_version` (this package's own version),
-`waiting_quality` (always `"measured"` for kankaku/pi — it always
-instruments waiting time), `cost_quality` (`"measured"` when the task's
-own record or any joined subagent observed a real provider cost figure on
-at least one turn; `"unknown"` when none did, e.g. a subscription/OAuth
-provider that reports no cost — kankaku has no token-price estimator, so
-it never sends `"estimated"`), and `subagent_linkage` (`"not_applicable"`
-when the task opened no subagent spans; `"linked"` when at least as many
-child records were joined as spans were opened; `"unlinked"` otherwise —
-a task-level approximation, since there is no per-span correlation id
-today, see "Subagents" > "Limitations"). These are measurement fields, not
-assignment: sent on every create *and* update, and included in the sync
-content hash, so a background subagent that joins later — improving
-`cost_quality`/`subagent_linkage` without changing any other number —
-still triggers a resync. An older hub predating these fields simply
-ignores them (PocketBase silently drops unrecognized fields on write); no
-capability probing is needed.
+different agents: `agent` (`"pi"` for this package), `agent_version` (the
+agent's own version, when it could be determined — never guessed, omitted
+otherwise), `plugin` (`"kankaku"`), `plugin_version` (this package's own
+version), `waiting_quality` (always `"measured"` for kankaku/pi — it
+always instruments waiting time), `cost_quality` (`"measured"` when the
+task's own record or any joined subagent observed a real provider cost
+figure on at least one turn; `"unknown"` when none did, e.g. a
+subscription/OAuth provider that reports no cost — kankaku has no
+token-price estimator, so it never sends `"estimated"`), and
+`subagent_linkage` (`"not_applicable"` when the task opened no subagent
+spans; `"linked"` when at least as many child records were joined as spans
+were opened; `"unlinked"` otherwise — a task-level approximation, since
+there is no per-span correlation id today, see "Subagents" >
+"Limitations"). These are measurement fields, not assignment, but
+`agent`/`agent_version`/`plugin`/`plugin_version` specifically identify
+who *measured* the task, not who *syncs* it: they are taken from the
+orchestrator record's own `agent`/`agentVersion`/`plugin`/`pluginVersion`
+(see "Record schema") when it carries one, and only fall back to the
+syncing process's own identity for a legacy record written before this
+field existed. On create, `agent`/`plugin` are always sent (from the
+record or the fallback). On update, all four are sent when the record
+carries an identity, and OMITTED ENTIRELY for a legacy record — so a
+re-sync by a *different* process (a standalone `kankaku` TUI, or a
+different agent syncing a shared directory) can never overwrite a row's
+original identity with its own. `waiting_quality`/`cost_quality`/
+`subagent_linkage` are unaffected by this and are always sent on both
+create and update. All of these are included in the sync content hash
+(the record's own `agent`/`plugin`, not their versions), so a background
+subagent that joins later, or a task that first gains a who-measured
+identity — improving `cost_quality`/`subagent_linkage`/`agent` without
+changing any other number — still triggers a resync. An older hub
+predating these fields simply ignores them (PocketBase silently drops
+unrecognized fields on write); no capability probing is needed.
 
 **Session directory.** `session_dir` carries a task's non-default session
 directory (`TaskView.sessionDir`, see "Record schema") to the hub, so a
@@ -1329,8 +1360,16 @@ separate CLI or another agent's plugin (e.g. the `kankaku-claude` package):
   adapters against.
 - `kankaku/hub` — the pi-free adapters: the PocketBase HTTP client and
   catalog/sink, `runSync`, the JSONL work log, the cached catalog, hub
-  credentials, and related filesystem helpers. Nothing reachable from this
-  entry point ever imports a pi package type.
+  credentials, and related filesystem helpers; also the report formatters
+  and the five report view builders (`formatReport`, `summarize`,
+  `buildSummaryView`, `buildTasksView`, etc.), the hub action line-builders
+  (`buildSyncStatusLines`, `formatSyncSummaryLines`, ...), the export
+  writer (`writeExport`) and the project config reader/writer
+  (`readProjectTargetIds`, `writeProjectTargetIds`). These exist so a
+  standalone CLI or TUI (e.g. a future Ink-based one) can render the exact
+  same reports and hub actions as the `/kankaku` subcommands and panel,
+  without reimplementing them. Nothing reachable from this entry point ever
+  imports a pi package type.
 
 ```js
 import { runSync } from "kankaku/hub";

package/dist/adapters/export-writer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Write `content` to `<dir>/export/<name>` (creating the `export`
+ * subdirectory as needed, overwriting any existing file with the same
+ * name) and return the absolute path it was written to.
+ */
+export declare function writeExport(dir: string, name: string, content: string): string;
+/** Writes exports under a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export declare class LazyExportWriter {
+    private readonly dirOrRelative;
+    private readonly fallbackCwd;
+    constructor(dirOrRelative: string, fallbackCwd?: () => string);
+    write(name: string, content: string): string;
+}

package/dist/adapters/export-writer.js

@@ -0,0 +1,28 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { resolveKankakuDir } from "./kankaku-dir.js";
+const EXPORT_SUBDIR = "export";
+/**
+ * Write `content` to `<dir>/export/<name>` (creating the `export`
+ * subdirectory as needed, overwriting any existing file with the same
+ * name) and return the absolute path it was written to.
+ */
+export function writeExport(dir, name, content) {
+    const exportDir = join(dir, EXPORT_SUBDIR);
+    mkdirSync(exportDir, { recursive: true });
+    const filePath = resolve(join(exportDir, name));
+    writeFileSync(filePath, content);
+    return filePath;
+}
+/** Writes exports under a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export class LazyExportWriter {
+    dirOrRelative;
+    fallbackCwd;
+    constructor(dirOrRelative, fallbackCwd = () => process.cwd()) {
+        this.dirOrRelative = dirOrRelative;
+        this.fallbackCwd = fallbackCwd;
+    }
+    write(name, content) {
+        return writeExport(resolveKankakuDir(this.dirOrRelative, this.fallbackCwd()), name, content);
+    }
+}

package/dist/adapters/hub-actions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared line-building for the hub-facing `/kankaku` subcommands (`sync`,
+ * `sync all`, `sync status`, `backfill`, `catalog refresh`) and the panel's
+ * `sync`/`export` screens (`adapters/panel/screens/sync.ts`), extracted from
+ * `kankaku-command.ts` so the subcommands and the panel can never drift —
+ * see odd/tasks/kankaku-panel.md P4.
+ */
+import type { CatalogSnapshot } from "../ports/catalog.ts";
+import type { SyncStatusSnapshot, SyncSummary } from "./sync-runner.ts";
+/**
+ * `/kankaku sync status`'s report lines: the watermark, the pending count,
+ * how many tasks fell outside this run's revisit window (R3), and the last
+ * error, when any. Exact body of `handleSyncCommand`'s `status` branch.
+ */
+export declare function buildSyncStatusLines(status: SyncStatusSnapshot): string[];
+/**
+ * Render a {@link SyncSummary} as report lines: counts, any stop reason, the
+ * new watermark, and the unassigned/failed breakdowns. Used by `/kankaku
+ * sync`/`sync all` and the panel's sync screen.
+ */
+export declare function formatSyncSummaryLines(summary: SyncSummary): string[];
+/**
+ * `/kankaku backfill`'s report lines: tasks routed to Sin determinar this
+ * run, grouped by their old free-text label, or "no unassigned tasks" when
+ * none were. Exact body of `handleBackfillCommand`.
+ */
+export declare function formatBackfillLines(summary: SyncSummary): string[];
+/**
+ * `/kankaku catalog refresh`'s report lines: client/project counts, or an
+ * unreachable notice when the refresh failed (`snapshot` is `undefined`).
+ * The subcommand still notifies that failure as an error rather than a
+ * report (see `handleCatalogCommand`); the panel's sync screen shows
+ * whatever this returns either way.
+ */
+export declare function formatCatalogRefreshLines(snapshot: CatalogSnapshot | undefined): string[];

package/dist/adapters/hub-actions.js

@@ -0,0 +1,70 @@
+/**
+ * `/kankaku sync status`'s report lines: the watermark, the pending count,
+ * how many tasks fell outside this run's revisit window (R3), and the last
+ * error, when any. Exact body of `handleSyncCommand`'s `status` branch.
+ */
+export function buildSyncStatusLines(status) {
+    const { state, pending, staleOutsideWindow } = status;
+    const lines = [state?.syncedThrough ? `synced through ${state.syncedThrough}` : "never synced", `pending: ${pending}`];
+    if (staleOutsideWindow > 0) {
+        lines.push(`${staleOutsideWindow} task(s) never synced fall outside the sync window — run '/kankaku sync all' to upload them`);
+    }
+    if (state?.lastError)
+        lines.push(`last error: ${state.lastError.message} (at ${state.lastError.at})`);
+    return lines;
+}
+/**
+ * Render a {@link SyncSummary} as report lines: counts, any stop reason, the
+ * new watermark, and the unassigned/failed breakdowns. Used by `/kankaku
+ * sync`/`sync all` and the panel's sync screen.
+ */
+export function formatSyncSummaryLines(summary) {
+    const lines = [`uploaded ${summary.uploaded}, updated ${summary.updated}, skipped ${summary.skipped}, failed ${summary.failed.length}`];
+    if (summary.locked)
+        lines.push("another sync is already in progress; nothing was attempted");
+    if (summary.error)
+        lines.push(`stopped early: ${summary.error}`);
+    if (summary.syncedThrough)
+        lines.push(`synced through ${summary.syncedThrough}`);
+    const unassignedEntries = Object.entries(summary.unassigned).sort(([a], [b]) => a.localeCompare(b));
+    if (unassignedEntries.length > 0) {
+        lines.push("unassigned (Sin determinar):");
+        for (const [label, count] of unassignedEntries)
+            lines.push(`  ${label}: ${count}`);
+    }
+    if (summary.failed.length > 0) {
+        lines.push("failed:");
+        for (const entry of summary.failed)
+            lines.push(`  ${entry.id}: ${entry.reason}`);
+    }
+    return lines;
+}
+/**
+ * `/kankaku backfill`'s report lines: tasks routed to Sin determinar this
+ * run, grouped by their old free-text label, or "no unassigned tasks" when
+ * none were. Exact body of `handleBackfillCommand`.
+ */
+export function formatBackfillLines(summary) {
+    const unassignedEntries = Object.entries(summary.unassigned).sort(([a], [b]) => a.localeCompare(b));
+    const lines = unassignedEntries.length > 0
+        ? [
+            ...unassignedEntries.map(([label, count]) => `${label}: ${count} task(s) -> Sin determinar`),
+            "reassign these in the hub web app's unassigned queue",
+        ]
+        : ["no unassigned tasks"];
+    if (summary.error)
+        lines.push(`stopped early: ${summary.error}`);
+    return lines;
+}
+/**
+ * `/kankaku catalog refresh`'s report lines: client/project counts, or an
+ * unreachable notice when the refresh failed (`snapshot` is `undefined`).
+ * The subcommand still notifies that failure as an error rather than a
+ * report (see `handleCatalogCommand`); the panel's sync screen shows
+ * whatever this returns either way.
+ */
+export function formatCatalogRefreshLines(snapshot) {
+    if (!snapshot)
+        return ["hub unreachable; catalog not refreshed"];
+    return [`refreshed: ${snapshot.clients.length} client(s), ${snapshot.projects.length} project(s)`];
+}

package/dist/adapters/project-config.d.ts

@@ -0,0 +1,42 @@
+import type { WorkTargetCandidate } from "../domain/work-target.ts";
+/**
+ * Read the project's default billing client from `<dir>/config.json`
+ * (`{ "client": "acme" }`), the lowest-precedence source in
+ * `domain/client-label.ts#resolveClient`. `dir` is the kankaku dir (same
+ * directory as the work log).
+ *
+ * Tolerates a missing file, malformed JSON, a non-object document, or a
+ * `client` field that is not a string — all return `undefined` rather than
+ * throwing, since this file is optional and hand-edited.
+ */
+export declare function readProjectClient(dir: string): string | undefined;
+/** Reads the project client from a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export declare class LazyProjectClientSource {
+    private readonly dirOrRelative;
+    private readonly fallbackCwd;
+    constructor(dirOrRelative: string, fallbackCwd?: () => string);
+    read(): string | undefined;
+}
+/**
+ * Read `clientId`/`projectId` from `<dir>/config.json`, the lowest-precedence
+ * source in `domain/work-target.ts#resolveWorkTarget`. Tolerates the same
+ * failure modes as {@link readProjectClient}. `undefined` when `clientId`
+ * is absent or not a string (a `projectId` without a `clientId` is not a
+ * valid candidate); a non-string `projectId` is dropped, keeping `clientId`.
+ */
+export declare function readProjectTargetIds(dir: string): WorkTargetCandidate | undefined;
+/**
+ * Merge `clientId`/`projectId` into `<dir>/config.json`, preserving every
+ * other existing key (including the legacy `client` label). Writes
+ * atomically (tmp + rename), mirroring `file-inflight-store.ts`. A missing
+ * or malformed existing file is treated as `{}` rather than failing.
+ */
+export declare function writeProjectTargetIds(dir: string, ids: WorkTargetCandidate): void;
+/** Reads target ids from a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export declare class LazyProjectTargetSource {
+    private readonly dirOrRelative;
+    private readonly fallbackCwd;
+    constructor(dirOrRelative: string, fallbackCwd?: () => string);
+    read(): WorkTargetCandidate | undefined;
+    write(ids: WorkTargetCandidate): void;
+}

package/dist/adapters/project-config.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveKankakuDir } from "./kankaku-dir.js";
+const CONFIG_FILE_NAME = "config.json";
+/**
+ * Read the project's default billing client from `<dir>/config.json`
+ * (`{ "client": "acme" }`), the lowest-precedence source in
+ * `domain/client-label.ts#resolveClient`. `dir` is the kankaku dir (same
+ * directory as the work log).
+ *
+ * Tolerates a missing file, malformed JSON, a non-object document, or a
+ * `client` field that is not a string — all return `undefined` rather than
+ * throwing, since this file is optional and hand-edited.
+ */
+export function readProjectClient(dir) {
+    const filePath = join(dir, CONFIG_FILE_NAME);
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const client = parsed["client"];
+        return typeof client === "string" ? client : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Reads the project client from a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export class LazyProjectClientSource {
+    dirOrRelative;
+    fallbackCwd;
+    constructor(dirOrRelative, fallbackCwd = () => process.cwd()) {
+        this.dirOrRelative = dirOrRelative;
+        this.fallbackCwd = fallbackCwd;
+    }
+    read() {
+        return readProjectClient(resolveKankakuDir(this.dirOrRelative, this.fallbackCwd()));
+    }
+}
+/**
+ * Read `clientId`/`projectId` from `<dir>/config.json`, the lowest-precedence
+ * source in `domain/work-target.ts#resolveWorkTarget`. Tolerates the same
+ * failure modes as {@link readProjectClient}. `undefined` when `clientId`
+ * is absent or not a string (a `projectId` without a `clientId` is not a
+ * valid candidate); a non-string `projectId` is dropped, keeping `clientId`.
+ */
+export function readProjectTargetIds(dir) {
+    const filePath = join(dir, CONFIG_FILE_NAME);
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const record = parsed;
+        const clientId = record["clientId"];
+        if (typeof clientId !== "string")
+            return undefined;
+        const projectId = record["projectId"];
+        return typeof projectId === "string" ? { clientId, projectId } : { clientId };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Merge `clientId`/`projectId` into `<dir>/config.json`, preserving every
+ * other existing key (including the legacy `client` label). Writes
+ * atomically (tmp + rename), mirroring `file-inflight-store.ts`. A missing
+ * or malformed existing file is treated as `{}` rather than failing.
+ */
+export function writeProjectTargetIds(dir, ids) {
+    const filePath = join(dir, CONFIG_FILE_NAME);
+    let existing = {};
+    if (existsSync(filePath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                existing = parsed;
+            }
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const merged = { ...existing, clientId: ids.clientId, ...(ids.projectId !== undefined ? { projectId: ids.projectId } : {}) };
+    mkdirSync(dir, { recursive: true });
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(merged, null, 2));
+    renameSync(tmp, filePath);
+}
+/** Reads target ids from a kankaku dir resolved lazily against `fallbackCwd()` at call time. */
+export class LazyProjectTargetSource {
+    dirOrRelative;
+    fallbackCwd;
+    constructor(dirOrRelative, fallbackCwd = () => process.cwd()) {
+        this.dirOrRelative = dirOrRelative;
+        this.fallbackCwd = fallbackCwd;
+    }
+    read() {
+        return readProjectTargetIds(resolveKankakuDir(this.dirOrRelative, this.fallbackCwd()));
+    }
+    write(ids) {
+        writeProjectTargetIds(resolveKankakuDir(this.dirOrRelative, this.fallbackCwd()), ids);
+    }
+}

package/dist/adapters/report-data.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pi-free home for {@link KankakuReportData}, the shape every `/kankaku`
+ * report view and the panel's report screen produce. Extracted out of
+ * `kankaku-command.ts` (which still re-exports it) so `report-views.ts` can
+ * be published through `kankaku/hub` without pulling in anything that
+ * touches `@earendil-works/*` — see AGENTS.md "Code conventions".
+ */
+/** Durable report rendered inside the chat transcript; never sent to the LLM. */
+export interface KankakuReportData {
+    title: string;
+    lines: string[];
+}

package/dist/adapters/report-data.js

@@ -0,0 +1,8 @@
+/**
+ * Pi-free home for {@link KankakuReportData}, the shape every `/kankaku`
+ * report view and the panel's report screen produce. Extracted out of
+ * `kankaku-command.ts` (which still re-exports it) so `report-views.ts` can
+ * be published through `kankaku/hub` without pulling in anything that
+ * touches `@earendil-works/*` — see AGENTS.md "Code conventions".
+ */
+export {};

package/dist/adapters/report-views.d.ts

@@ -0,0 +1,45 @@
+import type { WorkRecord } from "../domain/work-record.ts";
+import type { KankakuReportData } from "./report-data.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 declare function buildSummaryView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData;
+/** `/kankaku clients [all]`: per-client totals. */
+export declare function buildClientsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData;
+/** `/kankaku projects [all]`: per-project totals. */
+export declare function buildProjectsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData;
+/** `/kankaku sessions [all]`: per-session totals. */
+export declare function buildSessionsView(records: WorkRecord[], options: ReportViewOptions): KankakuReportData;
+/**
+ * `/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 declare function buildTasksView(records: WorkRecord[], options: TasksViewOptions): KankakuReportData;
+/** {@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 declare function buildExportContent(records: WorkRecord[], options: ExportContentOptions): {
+    name: string;
+    content: string;
+    rowCount: number;
+};

package/dist/adapters/report-views.js

@@ -0,0 +1,73 @@
+/**
+ * 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.js";
+import { exportRows, toCsv, toJson } from "../domain/export.js";
+import { countUncertain, formatClients, formatProjects, formatReport, formatSessions, formatTasks, localDay, summarize, summarizeByClient, summarizeByProject } from "./report.js";
+/** 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, options) {
+    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, options) {
+    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, options) {
+    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, options) {
+    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, options) {
+    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") };
+}
+/**
+ * `/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, options) {
+    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 };
+}