kankaku 0.6.5 → 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;

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/session-target.ts

@@ -81,6 +81,24 @@ export interface SessionTarget {
   pickTask(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void>;
   /** `/kankaku task clear`: drops the linked hub task, keeping the rest of the session target. A no-op when none is linked. */
   clearTask(pi: ExtensionAPI): void;
+  /**
+   * Set the linked hub task directly, bypassing the picker — the panel's
+   * target screen (`adapters/panel/screens/target.ts`) uses this once the
+   * user has already chosen a task from its own `SelectList`. Builds the
+   * session override from the current {@link effectiveTarget}'s candidate
+   * plus `hubTaskId` and appends the session entry, exactly like
+   * {@link pickTask}'s own persistence step. A no-op when there is no
+   * effective target with a project.
+   */
+  setTask(pi: ExtensionAPI, hubTaskId: string): void;
+  /**
+   * `/kankaku target remember` / the panel's "Remember" row: persists the
+   * current {@link effectiveTarget}'s `clientId`/`projectId` (never
+   * `hubTaskId` — task linking stays session-only) to the project's
+   * `.kankaku/config.json`. Returns `false`, without persisting anything,
+   * when there is no effective target.
+   */
+  rememberTarget(): boolean;
   /** Current effective target (session > project config > repoPaths), regardless of role. */
   effectiveTarget(): WorkTarget | undefined;
   /** Which source produced {@link effectiveTarget}. */
@@ -346,6 +364,22 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     pi.appendEntry<KankakuTargetEntryData>(TARGET_ENTRY_TYPE, {});
   }
 
+  function setTask(pi: ExtensionAPI, hubTaskId: string): void {
+    const target = effectiveTarget();
+    if (!target || target.projectId === undefined) return;
+
+    const ids: WorkTargetCandidate = { ...candidateFrom(target), hubTaskId };
+    sessionOverride = ids;
+    pi.appendEntry<KankakuTargetEntryData>(TARGET_ENTRY_TYPE, entryDataFrom(ids));
+  }
+
+  function rememberTarget(): boolean {
+    const target = effectiveTarget();
+    if (!target) return false;
+    deps.persistProjectConfig(candidateFrom(target));
+    return true;
+  }
+
   async function pickTask(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
     if (deps.role !== "orchestrator" || !ctx.hasUI) return;
 
@@ -364,9 +398,7 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     }
     if (result.kind === "skipped") return;
 
-    const ids: WorkTargetCandidate = { ...candidateFrom(target), hubTaskId: result.task.id };
-    sessionOverride = ids;
-    pi.appendEntry<KankakuTargetEntryData>(TARGET_ENTRY_TYPE, entryDataFrom(ids));
+    setTask(pi, result.task.id);
 
     const updated = effectiveTarget();
     if (updated) ctx.ui.notify(`kankaku: task set to ${formatWorkTargetLabel(updated)}`);
@@ -380,5 +412,20 @@ export function createSessionTarget(deps: SessionTargetDeps): SessionTarget {
     pi.appendEntry<KankakuTargetEntryData>(TARGET_ENTRY_TYPE, entryDataFrom(rest));
   }
 
-  return { restore, ensurePicked, pick, setExplicit, clear, pickTask, clearTask, effectiveTarget, effectiveSource, runTarget, idleTarget, endRun };
+  return {
+    restore,
+    ensurePicked,
+    pick,
+    setExplicit,
+    clear,
+    pickTask,
+    clearTask,
+    setTask,
+    rememberTarget,
+    effectiveTarget,
+    effectiveSource,
+    runTarget,
+    idleTarget,
+    endRun,
+  };
 }

package/src/domain/panel-model.ts

@@ -0,0 +1,267 @@
+/**
+ * Pure model for the `/kankaku` panel (see odd/tasks/kankaku-panel.md): the
+ * set of screens, the root menu, an immutable navigation stack, the
+ * title/footer-hint text every adapter screen renders from, and pure row
+ * builders (e.g. {@link buildTargetRows}) that turn kankaku state into row
+ * models for a screen's `SettingsList`. No I/O, no pi imports — see
+ * AGENTS.md "Architecture (hexagonal)".
+ */
+
+import type { WorkTarget } from "./work-target.ts";
+
+export type PanelScreenId = "root" | "target" | "report" | "sync" | "export" | "doctor" | "about";
+
+/** One row of the root menu (`rootMenu`): a section the panel can navigate to. */
+export interface PanelMenuItem {
+  id: PanelScreenId;
+  label: string;
+  description: string;
+  /** Offered only when the hub (PocketBase) is configured; see {@link rootMenu}. */
+  hubOnly: boolean;
+}
+
+const ROOT_MENU_ITEMS: PanelMenuItem[] = [
+  // Not hub-only: the legacy billing label (`/kankaku client <name>`) is
+  // set from this same screen and works with no hub configured at all.
+  { id: "target", label: "Target", description: "Billing client, project, hub task, legacy label", hubOnly: false },
+  { id: "report", label: "Report", description: "Today/all totals, tasks, sessions, clients, projects", hubOnly: false },
+  { id: "sync", label: "Sync", description: "Status, sync now, sync all, backfill, catalog refresh", hubOnly: true },
+  { id: "export", label: "Export", description: "Write today's or every task as csv/json", hubOnly: false },
+  { id: "doctor", label: "Doctor", description: "Orphan/uncertain subagent counts, ancestor detection", hubOnly: false },
+  { id: "about", label: "About", description: "Versions, KANKAKU_DIR, env-only config", hubOnly: false },
+];
+
+/**
+ * The root menu's rows, in a fixed order. `hubOnly` rows (only `sync`;
+ * `target` is not hub-only — see `ROOT_MENU_ITEMS`'s comment) are omitted
+ * entirely when the hub is not configured, so the panel offers exactly what
+ * `/kankaku` itself would today.
+ */
+export function rootMenu(options: { hubConfigured: boolean }): PanelMenuItem[] {
+  return ROOT_MENU_ITEMS.filter((item) => options.hubConfigured || !item.hubOnly);
+}
+
+/** Immutable navigation stack: `stack[0]` is always `"root"`. */
+export interface PanelNav {
+  stack: PanelScreenId[];
+}
+
+/** A fresh navigation stack, positioned at the root screen. */
+export function navRoot(): PanelNav {
+  return { stack: ["root"] };
+}
+
+/** Push a screen onto the stack, returning a new {@link PanelNav}; the input is never mutated. */
+export function navPush(nav: PanelNav, id: PanelScreenId): PanelNav {
+  return { stack: [...nav.stack, id] };
+}
+
+/**
+ * Pop the current screen, returning a new {@link PanelNav} and whether the
+ * panel should close. At the root, there is nothing left to pop: the stack
+ * is returned unchanged and `closed` is `true` — the caller closes the
+ * overlay instead of navigating.
+ */
+export function navBack(nav: PanelNav): { nav: PanelNav; closed: boolean } {
+  if (nav.stack.length <= 1) {
+    return { nav, closed: true };
+  }
+  return { nav: { stack: nav.stack.slice(0, -1) }, closed: false };
+}
+
+/** The screen currently on top of the stack. */
+export function navCurrent(nav: PanelNav): PanelScreenId {
+  return nav.stack[nav.stack.length - 1] ?? "root";
+}
+
+const SCREEN_TITLES: Record<Exclude<PanelScreenId, "root">, string> = {
+  target: "Target",
+  report: "Report",
+  sync: "Sync",
+  export: "Export",
+  doctor: "Doctor",
+  about: "About",
+};
+
+/** `kankaku` at root, `kankaku · <Screen>` on every other screen. */
+export function panelTitle(screen: PanelScreenId): string {
+  if (screen === "root") return "kankaku";
+  return `kankaku · ${SCREEN_TITLES[screen]}`;
+}
+
+/** One clickable/keyboard hint shown in the panel's footer. */
+export interface PanelHint {
+  key: string;
+  label: string;
+}
+
+/**
+ * The footer hint row for a screen: navigation hints, an optional search
+ * hint when the current body supports it, and how Escape/`q` behave — back
+ * at root closes the panel outright, so root shows only `esc close`; every
+ * other screen shows both `esc back` and `q close`.
+ */
+export function footerHints(screen: PanelScreenId, options: { searchable: boolean }): PanelHint[] {
+  const hints: PanelHint[] = [{ key: "↑↓", label: "move" }];
+
+  if (screen === "root") {
+    hints.push({ key: "enter", label: "open" });
+    if (options.searchable) hints.push({ key: "/", label: "search" });
+    hints.push({ key: "esc", label: "close" });
+    return hints;
+  }
+
+  hints.push({ key: "enter", label: "select" });
+  if (options.searchable) hints.push({ key: "/", label: "search" });
+  hints.push({ key: "esc", label: "back" }, { key: "q", label: "close" });
+  return hints;
+}
+
+/** One row of a `SettingsList`-backed screen (e.g. {@link buildTargetRows}'s output). */
+export interface PanelRow {
+  id: string;
+  label: string;
+  value: string;
+  description?: string;
+}
+
+const NONE_VALUE = "— none —";
+
+/** Pure input for {@link buildTargetRows}. */
+export interface TargetRowsInput {
+  /** Whether the hub (PocketBase) is configured; see `rootMenu`'s `target` row, which is offered either way. */
+  hubConfigured: boolean;
+  /** The current effective hub target, if any (`SessionTarget#effectiveTarget()`). */
+  target?: WorkTarget;
+  /** Which source produced {@link target} (already formatted by the caller as `"session" | "config" | "repoPaths"`), or `undefined` for none. */
+  source?: string;
+  /** The current effective legacy billing label (`SessionClient#effectiveClient()`), if any. */
+  legacyLabel?: string;
+  /** Which source produced {@link legacyLabel} (already formatted by the caller), or `undefined` for none. */
+  legacySource?: string;
+}
+
+/**
+ * Build the target screen's rows from kankaku's current billing-target
+ * state. Pure: the caller (`adapters/panel/screens/target.ts`) resolves
+ * `target`/`source`/`legacyLabel`/`legacySource` from `SessionTarget`/
+ * `SessionClient` and formats each source name as a plain string, so this
+ * function never depends on their concrete types.
+ *
+ * `client`/`project`/`task`/`source`/`remember` are included only when
+ * {@link TargetRowsInput.hubConfigured} is `true` — the panel's `target`
+ * screen is offered either way (see `rootMenu`), but those rows only make
+ * sense once a hub exists to resolve them against. `legacy` is always
+ * included: the legacy billing label works with no hub at all.
+ */
+export function buildTargetRows(input: TargetRowsInput): PanelRow[] {
+  const rows: PanelRow[] = [];
+  const target = input.target;
+  const hasClient = target !== undefined;
+  const hasProject = target !== undefined && target.projectId !== undefined;
+
+  if (input.hubConfigured) {
+    rows.push({
+      id: "client",
+      label: "Client",
+      value: hasClient ? `${target.clientName} (${target.clientCode})` : NONE_VALUE,
+    });
+
+    rows.push({
+      id: "project",
+      label: "Project",
+      value: hasProject ? (target.projectName ?? NONE_VALUE) : NONE_VALUE,
+      ...(hasClient ? {} : { description: "pick a client first" }),
+    });
+
+    rows.push({
+      id: "task",
+      label: "Task",
+      value: hasProject && target.hubTaskTitle !== undefined ? target.hubTaskTitle : NONE_VALUE,
+      ...(hasProject ? {} : { description: "pick a project first" }),
+    });
+
+    rows.push({
+      id: "source",
+      label: "Source",
+      value: input.source ?? "none",
+    });
+
+    rows.push({
+      id: "remember",
+      label: "Remember",
+      value: "save to config.json",
+      description: "Saves the client and project (never the linked task) to this repository's .kankaku/config.json.",
+    });
+  }
+
+  rows.push({
+    id: "legacy",
+    label: "Legacy label",
+    value: input.legacyLabel ?? NONE_VALUE,
+    description: `Source: ${input.legacySource ?? "none"}`,
+  });
+
+  return rows;
+}
+
+/**
+ * Pure input for {@link buildAboutRows}. Every env-only value is passed in
+ * already extracted from `KankakuConfig` (see `config.ts`) rather than the
+ * config object itself: `KankakuConfig` lives outside `src/domain/`, and
+ * this module must import nothing but `src/domain/`/`src/ports/` (see
+ * AGENTS.md "Architecture (hexagonal)").
+ */
+export interface AboutRowsInput {
+  /** kankaku's own version (`adapters/agent-info.ts#resolvePluginVersion`). */
+  pluginVersion?: string;
+  /** pi's version (`adapters/agent-info.ts#resolveAgentVersion`). */
+  agentVersion?: string;
+  /** This session's resolved kankaku directory (`adapters/kankaku-dir.ts#resolveKankakuDir`). */
+  kankakuDir: string;
+  /** The hub (PocketBase) URL, when configured. */
+  hubUrl?: string;
+  /** `KankakuConfig.interactiveTools`. */
+  interactiveTools: string[];
+  /** `KankakuConfig.segmentRules.length`. */
+  segmentRuleCount: number;
+  /** `KankakuConfig.subagentProfiles`' ids. */
+  subagentProfileNames: string[];
+  /** `KankakuConfig.client`. */
+  client?: string;
+}
+
+/**
+ * Build the panel's `about` screen rows: versions, the resolved directory,
+ * the hub URL, and every env-only setting (`KANKAKU_INTERACTIVE_TOOLS`,
+ * `KANKAKU_SEGMENTS`, `KANKAKU_SUBAGENT_TOOLS`/`KANKAKU_SUBAGENT_CHILD_ENV`,
+ * `KANKAKU_CLIENT`) with its env var name as the row's description — every
+ * row is read-only (see `screens/about.ts`).
+ */
+export function buildAboutRows(input: AboutRowsInput): PanelRow[] {
+  return [
+    { id: "kankaku", label: "kankaku", value: input.pluginVersion ?? "unknown" },
+    { id: "pi", label: "pi", value: input.agentVersion ?? "unknown" },
+    { id: "directory", label: "Directory", value: input.kankakuDir },
+    { id: "hub", label: "Hub", value: input.hubUrl ?? "not configured" },
+    {
+      id: "interactive-tools",
+      label: "Interactive tools",
+      value: input.interactiveTools.length > 0 ? input.interactiveTools.join(", ") : NONE_VALUE,
+      description: "KANKAKU_INTERACTIVE_TOOLS",
+    },
+    {
+      id: "segments",
+      label: "Segments",
+      value: `${input.segmentRuleCount} rule(s)`,
+      description: "KANKAKU_SEGMENTS",
+    },
+    {
+      id: "subagent-profiles",
+      label: "Subagent profiles",
+      value: input.subagentProfileNames.length > 0 ? input.subagentProfileNames.join(", ") : NONE_VALUE,
+      description: "KANKAKU_SUBAGENT_TOOLS / KANKAKU_SUBAGENT_CHILD_ENV",
+    },
+    { id: "client", label: "Client", value: input.client ?? NONE_VALUE, description: "KANKAKU_CLIENT" },
+  ];
+}

package/src/extension.ts

@@ -184,6 +184,18 @@ export default function kankaku(pi: ExtensionAPI): void {
   let hubConfigError: string | undefined;
   let sync: SyncCommandDeps | undefined;
   let autoSyncEnabled: boolean | undefined;
+  let hubUrl: string | undefined;
+
+  // Resolved once, here (never on a hot path): see README "Hub
+  // (PocketBase)" > "Agent and measurement quality" and the panel's `about`
+  // screen (`adapters/panel/screens/about.ts`). Both degrade to `undefined`
+  // on any failure rather than guessing. Unlike the sync sink below (which
+  // needs them only when the hub is configured), the `about` screen shows
+  // these regardless — so they are resolved unconditionally here.
+  const agentVersion = resolveAgentVersion();
+  // extension.ts lives at <package root>/src/extension.ts.
+  const pluginPackageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const pluginVersion = resolvePluginVersion(pluginPackageRoot);
 
   // `homeDir` is passed as a reference, never invoked here: any failure
   // resolving it (no HOME, a sandbox) must not fail extension load for
@@ -194,6 +206,7 @@ export default function kankaku(pi: ExtensionAPI): void {
 
   if (hub.credentials) {
     const credentials = hub.credentials;
+    hubUrl = credentials.url;
     const client = new PocketBaseClient({ url: credentials.url, email: credentials.email, password: credentials.password });
     // Same defensive resolution as above; falls back to the OS temp dir
     // when no home directory is available so an env-only hub configuration
@@ -226,14 +239,6 @@ export default function kankaku(pi: ExtensionAPI): void {
     const catalogRef = catalog;
     const machineName = machine;
 
-    // Resolved once, here (never on a hot path): see README "Hub
-    // (PocketBase)" > "Agent and measurement quality". Both degrade to
-    // `undefined` on any failure rather than guessing.
-    const agentVersion = resolveAgentVersion();
-    // extension.ts lives at <package root>/src/extension.ts.
-    const pluginPackageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
-    const pluginVersion = resolvePluginVersion(pluginPackageRoot);
-
     const runOnce = (options?: { full?: boolean; trigger?: SyncTrigger }) => {
       const snapshot = catalogRef.read();
       const sink = new PocketBaseSink({
@@ -309,6 +314,11 @@ export default function kankaku(pi: ExtensionAPI): void {
     ...(hubConfigError !== undefined ? { hubConfigError } : {}),
     ...(sync !== undefined ? { sync } : {}),
     ...(autoSyncEnabled !== undefined ? { autoSyncEnabled } : {}),
+    config,
+    kankakuDir: resolvedDir,
+    ...(agentVersion !== undefined ? { agentVersion } : {}),
+    ...(pluginVersion !== undefined ? { pluginVersion } : {}),
+    ...(hubUrl !== undefined ? { hubUrl } : {}),
     ...(roleOverride !== undefined ? { roleOverride } : {}),
     ...(childMarkerPresent ? { childMarkerPresent } : {}),
     ...(profile !== undefined ? { profile } : {}),