@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/fusion/src/tools.ts

@@ -1,8 +1,10 @@
 import { Text, type Component } from "@earendil-works/pi-tui";
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { isChildProcess, registerWaitSource } from "@pi-unipi/core";
 import type { SidekickRuntime, HandoffProgress, HandoffReport } from "./sidekick-runtime.js";
-import { duration, frameSidekick, markdownText, renderSidekickTranscript, sidekickWorkingHeader } from "./transcript.js";
+import { createCompletionDelivery, registerSubagentReader, type SubagentReader } from "@pi-unipi/core/child-agent.js";
+import { duration } from "./transcript.js";
 
 const SidekickParams = Type.Object({
   message: Type.String({ description: "A concrete implementation or verification brief for the sidekick" }),
@@ -22,46 +24,6 @@ export interface FusionToolDeps {
   onDetach?: (ctx: ExtensionContext) => void;
 }
 
-/**
- * Exactly-once completion delivery for handoffs nobody is waiting on.
- *
- * `attach`/`detach` bracket every waiting period. The completion is sent only
- * if the report lands (or has already landed) while no waiter is attached, and
- * only once per handoff id.
- */
-export function createCompletionDelivery(send: (report: HandoffReport) => void): {
-  attach(id: string): void;
-  detach(id: string, done: Promise<HandoffReport>): void;
-  consume(id: string): void;
-} {
-  const waiting = new Set<string>();
-  const armed = new Set<string>();
-  const delivered = new Set<string>();
-
-  return {
-    attach(id) {
-      waiting.add(id);
-    },
-    detach(id, done) {
-      waiting.delete(id);
-      // One continuation per handoff, however many times a waiter gives up.
-      if (armed.has(id)) return;
-      armed.add(id);
-      void done
-        .then((report) => {
-          if (waiting.has(id) || delivered.has(id)) return;
-          delivered.add(id);
-          send(report);
-        })
-        .catch(() => undefined);
-    },
-    consume(id) {
-      waiting.delete(id);
-      delivered.add(id);
-    },
-  };
-}
-
 function firstLine(value: string): string {
   return value.split("\n", 1)[0] ?? "";
 }
@@ -141,95 +103,86 @@ type ThemeLike = {
   bold: (text: string) => string;
 };
 
-type FramedTheme = ThemeLike & { bg: (color: string, text: string) => string };
-
-function transcriptStatus(partial: boolean, report: HandoffReport | undefined): "working" | "completed" | "error" {
-  if (partial) return "working";
-  return report?.status === "completed" ? "completed" : "error";
-}
-
 /**
- * Sidekick output on the main surface: the same markdown/tool format the lead
- * uses, marked as sidekick-origin by the existing `▍` rail.
+ * In-flight NON-blocking handoffs, for the turn arbiter's wait source: a
+ * block:false sidekick is still working while the lead settles, so the
+ * arbiter must defer (its completion lands as an event turn). Blocking
+ * handoffs never reach settle (the lead waits inside the tool call), and
+ * interrupted waits detach to background the same way.
  */
-function frameTranscript(theme: ThemeLike, status: "working" | "completed" | "error", content: Component): Component {
-  return frameSidekick(theme as FramedTheme, status, content);
-}
+export class BackgroundHandoffTracker {
+  private readonly handoffs = new Map<string, Promise<HandoffReport>>();
 
-// Model-facing result text carries handoff ids and protocol instructions the
-// lead needs; none of it may reach the terminal. Anything rendered as plain
-// content goes through this first.
-const HANDOFF_ID = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
-function displayText(text: string): string {
-  return text
-    .replace(/<\/?subagent_completion_notification[^>]*>/g, "")
-    .replace(/use `?read_subagent`?[^.\n]*\.?/gi, "")
-    .replace(HANDOFF_ID, "")
-    .replace(/agent_id[ =]?"?"?/g, "")
-    .replace(/read_subagent\([^)]*\)/g, "read_subagent")
-    .replace(/\(\s*\)/g, "")
-    .replace(/[ \t]{2,}/g, " ")
-    .replace(/\bHandoff\s*(?=(is|was|failed|aborted|started)\b)/g, "The handoff ")
-    .replace(/ for\s*\./g, ".")
-    .replace(/ +$/gm, "")
-    .trim();
-}
+  /** Track a detached handoff. Cleanup queues behind the completion delivery: every caller detaches the delivery BEFORE tracking, so the wait source only clears after the completion followUp is queued. */
+  track(id: string, done: Promise<HandoffReport>): void {
+    void done.catch(() => undefined).then(() => this.handoffs.delete(id));
+    this.handoffs.set(id, done);
+  }
 
-function contentText(content: unknown): string {
-  if (!Array.isArray(content)) return String(content ?? "");
-  return content.map((part) => typeof part === "object" && part !== null && typeof (part as { text?: unknown }).text === "string" ? (part as { text: string }).text : "").filter(Boolean).join("\n");
-}
+  get size(): number {
+    return this.handoffs.size;
+  }
 
-function backgroundComponent(theme: ThemeLike): Component {
-  return new Text(`${theme.fg("accent", theme.bold("◆ sidekick"))} ${theme.fg("dim", "· continuing in background")}`, 0, 0);
+  /** Arbiter wait-source reason, or null when nothing is in flight. */
+  reason(): string | null {
+    return this.handoffs.size > 0 ? "sidekick working" : null;
+  }
 }
 
-type ToolDetails = Partial<HandoffReport> & { progress?: HandoffProgress; background?: boolean; id?: string };
 
-function reportHeader(theme: ThemeLike, label: string, report: HandoffReport | undefined): string {
-  const status = report?.status ?? "done";
-  return `${theme.fg(status === "completed" ? "success" : "error", "◆")} ${theme.fg("accent", theme.bold(`${label} ${status}`))} ${theme.fg("dim", report ? `· ${String(report.toolCalls)} tool calls · ${duration(report.durationMs)} · in ${String(report.usage.input)} / out ${String(report.usage.output)} tokens` : "")}`;
-}
+type ToolDetails = Partial<HandoffReport> & { progress?: HandoffProgress; background?: boolean; id?: string };
 
-function renderToolTranscript(result: { content?: unknown; details?: unknown; isError?: boolean }, options: { expanded?: boolean }, theme: ThemeLike, label: "sidekick" | "read_subagent"): Component {
+/**
+ * Compact one-line tool status — the steps themselves stream as
+ * `sidekick-step` entries, so the tool card is just the status line:
+ * `◆ sidekick working · N steps · 12s` → `◆ sidekick done · N steps · 34s ·
+ * in X / out Y tokens`.
+ */
+function renderToolStatus(result: { content?: unknown; details?: unknown; isError?: boolean }, theme: ThemeLike): Component {
   const details = result.details as ToolDetails | undefined;
-  if (details?.background === true) return backgroundComponent(theme);
-  const hasProgress = details !== undefined && "progress" in details;
+  if (details?.background === true) {
+    return new Text(`${theme.fg("accent", "◆")} ${theme.fg("toolTitle", theme.bold("sidekick"))} ${theme.fg("dim", "· continuing in background")}`, 0, 0);
+  }
   const progress = details?.progress;
-  if (hasProgress && progress === undefined) return backgroundComponent(theme);
-  const report = progress ? undefined : details as HandoffReport | undefined;
-  const events = progress?.events ?? report?.events;
-  const partial = progress !== undefined;
-  if (!events) return new Text(displayText(contentText(result.content)), 0, 0);
-  const header = partial ? sidekickWorkingHeader(theme, progress, label) : reportHeader(theme, label, report);
-  return frameTranscript(theme, transcriptStatus(partial, report), renderSidekickTranscript(theme, {
-    events,
-    droppedEvents: progress?.droppedEvents,
-    header,
-    expanded: options.expanded === true,
-    isPartial: partial,
-    report,
-    renderText: markdownText,
-  }));
+  if (progress !== undefined) {
+    const steps = progress.toolCalls;
+    const elapsed = duration(Date.now() - progress.startedAt);
+    return new Text(`${theme.fg("accent", "◆")} ${theme.fg("toolTitle", theme.bold("sidekick"))} ${theme.fg("dim", `working · ${String(steps)} steps · ${elapsed}`)}`, 0, 0);
+  }
+  const report = details as HandoffReport | undefined;
+  const failed = result.isError === true || (report !== undefined && report.status !== "completed" && report.status !== undefined);
+  const glyph = failed ? theme.fg("error", "✗") : theme.fg("accent", "◆");
+  const label = failed ? "sidekick failed" : "sidekick done";
+  const meta = report?.durationMs !== undefined
+    ? ` · ${String(report.toolCalls)} steps · ${duration(report.durationMs)} · in ${String(report.usage?.input ?? 0)} / out ${String(report.usage?.output ?? 0)} tokens`
+    : "";
+  return new Text(`${glyph} ${theme.fg("toolTitle", theme.bold(label))}${theme.fg("dim", meta)}`, 0, 0);
 }
 
-function renderCompletionCard(theme: ThemeLike, report: HandoffReport | undefined): Component {
-  if (!report) return new Text(`${theme.fg("accent", "◆")} ${theme.fg("accent", theme.bold("sidekick done"))}`, 0, 0);
-  return frameTranscript(theme, transcriptStatus(false, report), renderSidekickTranscript(theme, {
-    events: report.events ?? [],
-    header: reportHeader(theme, "sidekick", report),
-    expanded: false,
-    isPartial: false,
-    report,
-    renderText: markdownText,
-  }));
+function renderCompletionLine(theme: ThemeLike, report: HandoffReport | undefined): Component {
+  const failed = report !== undefined && report.status !== "completed";
+  const glyph = failed ? theme.fg("error", "✗") : theme.fg("accent", "◆");
+  const label = failed ? "sidekick failed" : "sidekick finished";
+  const meta = report?.durationMs !== undefined ? ` · ${String(report.toolCalls)} steps · ${duration(report.durationMs)}` : "";
+  return new Text(`${glyph} ${theme.fg("dim", `${label}${meta}`)}`, 0, 0);
 }
 
 export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): void {
-  pi.registerMessageRenderer("sidekick-completion", (message: { details?: HandoffReport }, _options, theme) => renderCompletionCard(theme as unknown as ThemeLike, message.details));
+  // Turn-arbiter wait source (lead only).
+  const backgroundHandoffs = new BackgroundHandoffTracker();
+  const trackBackgroundHandoff = (id: string, done: Promise<HandoffReport>): void => backgroundHandoffs.track(id, done);
+  if (!isChildProcess()) {
+    try {
+      registerWaitSource("fusion", () => backgroundHandoffs.reason());
+    } catch {
+      // Registration must never block tool registration.
+    }
+  }
+
+  pi.registerMessageRenderer("sidekick-completion", (message: { details?: HandoffReport }, _options, theme) => renderCompletionLine(theme as unknown as ThemeLike, message.details));
 
   // One delivery mechanism for every handoff nobody is waiting on.
-  const completion = createCompletionDelivery((report) => {
+  const completion = createCompletionDelivery<HandoffReport>((report) => {
     pi.sendMessage(completionMessage(report) as never, { deliverAs: "followUp", triggerTurn: true } as never);
   });
 
@@ -239,7 +192,7 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
     description: "Hand off work to your persistent sidekick subagent (one per session; context and shells persist across handoffs; runs on the same machine). block:true (default) waits and returns the report. block:false returns immediately and the report arrives later as a <subagent_completion_notification>. Calling again while a handoff is running injects the message as an interrupt rather than starting a second sidekick.",
     parameters: SidekickParams,
     renderCall: (args, theme) => new Text(`${theme.fg("toolTitle", theme.bold("◆ sidekick"))} ${theme.fg("dim", firstLine(String(args.message)).slice(0, 100))}`, 0, 0),
-    renderResult: (result, options, theme) => renderToolTranscript(result, options, theme as unknown as ThemeLike, "sidekick"),
+    renderResult: (result, _options, theme) => renderToolStatus(result, theme as unknown as ThemeLike),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const runtime = deps.getRuntime(ctx);
       if (!runtime) return result("Fusion is not active — pick a Fusion pair with /unipi:model.", undefined, true);
@@ -249,18 +202,22 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
       if (params.block === false) {
         void handoff.done.then((report) => deps.onReport?.(ctx, report)).catch(() => undefined);
         completion.detach(handoff.id, handoff.done);
+        trackBackgroundHandoff(handoff.id, handoff.done);
         deps.onDetach?.(ctx);
         return result(`Handoff ${handoff.id} started in the background. You will receive a <subagent_completion_notification agent_id="${handoff.id}"> when it finishes; use read_subagent to wait.`, { background: true, id: handoff.id });
       }
       deps.onAttach?.(ctx);
+      runtime.attachUi?.(ctx.ui as never);
       completion.attach(handoff.id);
       const waited = await waitForReport(runtime, handoff.id, handoff.done, signal, ctx, onUpdate ? (update) => onUpdate(update as never) : undefined);
+      runtime.detachUi?.();
       if (waited.report) {
         completion.consume(handoff.id);
         deps.onReport?.(ctx, waited.report);
         return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
       }
       completion.detach(handoff.id, handoff.done);
+      trackBackgroundHandoff(handoff.id, handoff.done);
       deps.onDetach?.(ctx);
       if (waited.error) return result(`Handoff ${handoff.id} failed: ${waited.error}`, undefined, true);
       if (waited.aborted) return result(`${progressText(runtime, handoff.id)}\nHandoff ${handoff.id} aborted.`, undefined, true);
@@ -269,14 +226,19 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
     },
   });
 
-  pi.registerTool({
-    name: "read_subagent",
-    label: "Read Sidekick",
-    description: "Read a sidekick handoff report by agent_id (omit for the latest). block:true waits for completion (default timeout 2700s when omitted); block:false returns the current progress snapshot immediately.",
-    parameters: ReadSubagentParams,
-    renderCall: (args, theme) => new Text(`${theme.fg("toolTitle", theme.bold("◆ read_subagent"))} ${theme.fg("dim", args.block === false ? "· snapshot" : "· waiting")}`, 0, 0),
-    renderResult: (result, options, theme) => renderToolTranscript(result, options, theme as unknown as ThemeLike, "read_subagent"),
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+  // Fusion registers a READER for the shared `read_subagent` tool (core).
+  // Same semantics as before: consume completions, block:true waits with the
+  // shared timeout cap, interrupted waits detach to background.
+  const reader: SubagentReader = {
+    owns: (id, ctx) => runtime_reports_owns(deps, id, ctx ?? lastCtx),
+    latest: (ctx) => {
+      const ctx0 = ctx ?? lastCtx;
+      const rt = ctx0 === undefined ? undefined : deps.getRuntime(ctx0);
+      const latest = rt?.latest();
+      if (!latest || !rt) return undefined;
+      return { id: latest.id, startedAt: rt.progress(latest.id)?.startedAt ?? 0 };
+    },
+    read: async (params, signal, onUpdate, ctx) => {
       const runtime = deps.getRuntime(ctx);
       if (!runtime) return result("Fusion is not active — pick a Fusion pair with /unipi:model.", undefined, true);
       const latest = runtime.latest();
@@ -285,28 +247,45 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
       const selected = runtime.reports.get(id);
       if (selected) {
         completion.consume(id);
-        return result(reportText(selected), selected, selected.status !== "completed");
+        return result(reportText(selected), { ...selected, owner: "fusion" }, selected.status !== "completed");
       }
       if (id !== latest.id) return result(`No sidekick handoff found for ${id}.`, undefined, true);
-      if (params.block !== true) return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`, { progress: runtime.progress(id), id });
+      if (params.block !== true) return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`, { progress: runtime.progress(id), id, owner: "fusion" });
       deps.onAttach?.(ctx);
+      runtime.attachUi?.(ctx.ui as never);
       completion.attach(id);
-      const timeoutMs = (params.timeout ?? 2700) * 1000;
-      const waited = await waitForReport(runtime, id, latest.done, signal, ctx, onUpdate ? (update) => onUpdate(update as never) : undefined, timeoutMs);
+      const timeoutMs = Math.min(600, params.timeout ?? 30) * 1000;
+      const waited = await waitForReport(runtime, id, latest.done, signal, ctx, onUpdate, timeoutMs);
+      runtime.detachUi?.();
       if (waited.report) {
         completion.consume(id);
         deps.onReport?.(ctx, waited.report);
-        return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
+        return result(reportText(waited.report), { ...waited.report, owner: "fusion" }, waited.report.status !== "completed");
       }
       completion.detach(id, latest.done);
+      trackBackgroundHandoff(id, latest.done);
       deps.onDetach?.(ctx);
       if (waited.error) return result(`Handoff ${id} failed: ${waited.error}`, undefined, true);
       if (waited.aborted) return result(`Handoff ${id} aborted.`, undefined, true);
-      if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${id}) was working.\n${waited.interrupted}`, { progress: runtime.progress(id), id });
-      return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`, { progress: runtime.progress(id), id });
+      if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${id}) was working.\n${waited.interrupted}`, { progress: runtime.progress(id), id, owner: "fusion" });
+      return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`, { progress: runtime.progress(id), id, owner: "fusion" });
+    },
+  };
+  let lastCtx: ExtensionContext | undefined;
+  registerSubagentReader("fusion", {
+    owns: (id, ctx) => reader.owns(id, ctx),
+    latest: (ctx) => reader.latest(ctx),
+    read: (params, signal, onUpdate, ctx) => {
+      lastCtx = ctx;
+      return reader.read(params, signal, onUpdate, ctx);
     },
   });
 
+  function runtime_reports_owns(d: FusionToolDeps, id: string, ctx: ExtensionContext | undefined): boolean {
+    const rt = ctx === undefined ? undefined : d.getRuntime(ctx);
+    return rt !== undefined && (rt.reports.has(id) || rt.latest()?.id === id);
+  }
+
 }
 
 export { reportText, progressText };

package/packages/fusion/src/transcript.ts

@@ -1,10 +1,15 @@
-import { Box, Container, Markdown, Text, type Component } from "@earendil-works/pi-tui";
+import { Markdown, type Component } from "@earendil-works/pi-tui";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import type { HandoffProgress, SidekickEvent } from "./sidekick-runtime.js";
+import { renderDelegatedStep, type DelegatedStep } from "@pi-unipi/utility/src/render/delegated.js";
+import type { SidekickStep } from "./sidekick-runtime.js";
 
 export interface ThemeLike {
   fg: (color: string, text: string) => string;
   bold: (text: string) => string;
+  getBgAnsi?: (key: string) => string;
+  /** Colour mode when the caller knows it — the delegated panel uses it for
+   *  its truecolor/256 rail+fill+fg fallbacks. */
+  getColorMode?: () => "truecolor" | "256color";
 }
 
 export function duration(ms: number): string {
@@ -15,51 +20,6 @@ export function markdownText(markdown: string): Component {
   return new Markdown(markdown, 0, 0, getMarkdownTheme());
 }
 
-export function sidekickWorkingHeader(theme: ThemeLike, progress: Pick<HandoffProgress, "toolCalls" | "startedAt">, label = "sidekick"): string {
-  return `${theme.fg("accent", theme.bold(`◆ ${label} working`))} ${theme.fg("dim", `· ${String(progress.toolCalls)} tool calls · ${duration(Date.now() - progress.startedAt)}`)}`;
-}
-
-export class RailComponent implements Component {
-  constructor(private readonly inner: Component, private readonly rail: string) {}
-
-  render(width: number): string[] {
-    return this.inner.render(Math.max(1, width - 2)).map((line) => `${this.rail} ${line}`);
-  }
-
-  invalidate(): void {
-    this.inner.invalidate?.();
-  }
-
-  handleInput(data: string): void {
-    this.inner.handleInput?.(data);
-  }
-}
-
-export function frameSidekick(theme: ThemeLike & { bg: (color: string, text: string) => string }, status: "working" | "completed" | "error", content: Component): Component {
-  const railColor = status === "working" ? "accent" : status === "completed" ? "success" : "error";
-  const rail = theme.fg(railColor, "▍");
-  const boxed = new Box(1, 0, (text) => theme.bg("customMessageBg", text));
-  boxed.addChild(new RailComponent(content, rail));
-  return boxed;
-}
-
-export interface TranscriptOptions {
-  events: readonly SidekickEvent[];
-  droppedEvents?: number;
-  header: string;
-  expanded: boolean;
-  isPartial: boolean;
-  report?: { text: string };
-  renderText: (markdown: string) => Component;
-}
-
-/**
- * Non-expanded transcripts show this many most recent events. Windowing is the
- * only cap: a completed handoff renders its events, it is never collapsed into
- * a "N steps" stub.
- */
-export const TRANSCRIPT_WINDOW = 8;
-
 function firstLine(value: string): string {
   return value.split("\n", 1)[0] ?? "";
 }
@@ -80,44 +40,26 @@ export function primaryArg(name: string, args: Record<string, unknown> | undefin
   return typeof value === "string" ? truncate(firstLine(value), 100) : "";
 }
 
-function toolComponent(theme: ThemeLike, event: Extract<SidekickEvent, { kind: "tool" }>, expanded: boolean): Text {
-  const title = `${event.isError ? theme.fg("error", "✗ ") : ""}${theme.fg("toolTitle", theme.bold(event.name))}`;
-  const argument = primaryArg(event.name, event.args);
-  const lines = [`${title}${argument.length > 0 ? ` ${theme.fg("accent", argument)}` : ""}`];
-  if (!event.done) {
-    lines[0] += theme.fg("warning", " ⋯ running");
-  } else if (event.output.length > 0) {
-    const output = event.output.split("\n");
-    const visible = expanded ? output.slice(-40) : output.slice(-3);
-    lines.push(...visible.map((line) => theme.fg("toolOutput", truncate(line, 160))));
-  }
-  return new Text(lines.join("\n"), 0, 0);
-}
-
-export function renderSidekickTranscript(theme: ThemeLike, opts: TranscriptOptions): Component {
-  const box = new Container();
-  box.addChild(new Text(opts.header, 0, 0));
-
-  const dropped = opts.droppedEvents ?? 0;
-  const start = opts.expanded ? 0 : Math.max(0, opts.events.length - TRANSCRIPT_WINDOW);
-  if (opts.expanded && dropped > 0) {
-    box.addChild(new Text(theme.fg("dim", `… ${String(dropped)} earliest steps dropped`), 0, 0));
-  } else if (start > 0) {
-    box.addChild(new Text(theme.fg("dim", `… ${String(start + dropped)} earlier steps`), 0, 0));
-  }
+// ─── sidekick-step entry renderer (Devin-style merged steps) ────────────────
 
-  for (const event of opts.events.slice(start)) {
-    if (event.kind === "tool") box.addChild(toolComponent(theme, event, opts.expanded));
-    else if (event.text.trim()) box.addChild(opts.renderText(event.text.trim()));
-  }
+export interface StepIdentity {
+  /** spacingGroup run — unique per handoff so resumed handoffs don't merge. */
+  group?: string;
+  /** Panel header drawn once on the group's first position (e.g. "Sidekick"). */
+  label?: string;
+}
 
-  if (!opts.isPartial && opts.report?.text) {
-    // The final assistant message usually IS the report; don't print it twice.
-    const last = opts.events.at(-1);
-    if (!(last?.kind === "text" && last.text.trim() === opts.report.text.trim())) {
-      box.addChild(new Text(theme.fg("dim", "── report ──"), 0, 0));
-      box.addChild(opts.renderText(opts.report.text));
-    }
-  }
-  return box;
+/**
+ * One sidekick step in the lead chat, drawn by the shared delegated-panel
+ * helper: the active render style behind the approved cyan `▏` rail on a
+ * single dark-cyan fill. Steps carry `spacingGroup` so adjacent steps of the
+ * same handoff join into one continuous panel (`├…└` tree, no blank
+ * separators); the optional identity comes from the persisted entry (older
+ * entries without one fall back to the shared "sidekick" group).
+ */
+export function renderSidekickStep(step: SidekickStep, expanded: boolean, theme: ThemeLike, identity?: StepIdentity): Component {
+  return renderDelegatedStep(step as DelegatedStep, expanded, theme as never, {
+    group: identity?.group ?? "sidekick",
+    label: identity?.label,
+  });
 }

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/input-shortcuts/README.md

@@ -1,21 +1,19 @@
 # @pi-unipi/input-shortcuts
 
-Keyboard shortcuts for Pi's input box. Stash and restore text, undo/redo, clipboard operations, thinking level toggle, and tab insertion — all via a vim-style chord overlay triggered by `ALT+S`.
+Keyboard shortcuts for Pi's input box. Stash and restore text, undo/redo, copy the last response, push the editor text to the kanboard backlog, and tab insertion — all via a vim-style chord overlay triggered by `ALT+S`.
 
-Press `ALT+S`, a small overlay appears with key hints. Press a key, the action runs. The overlay closes automatically after 300ms or on `ESC`.
+Press `ALT+S`, a small overlay appears with key hints. Press a key, the action runs. The overlay closes automatically after selecting an action, on `ESC`, or on an unknown key.
 
 ## Shortcuts
 
 | Chord | Action | Description |
 |-------|--------|-------------|
-| `ALT+S → S` | Stash/Restore | Save input to stash register, or restore it |
-| `ALT+S → U` | Undo | Pop from undo buffer |
-| `ALT+S → R` | Redo | Push current text forward, restore previous |
-| `ALT+S → Y` | Copy | Copy input to system clipboard |
-| `ALT+S → D` | Cut | Copy to clipboard, then clear input |
-| `ALT+S → T` | Toggle Thinking | Cycle: off → low → medium → high → xhigh → off |
-| `ALT+S → A → [0-9]` | Append Register | Append from numbered register 0-9 |
-| `ALT+S → A → S` | Append Stash | Append from stash register |
+| `ALT+S → S` | Stash/Restore | Save input to the stash register, or restore it |
+| `ALT+S → U` | Undo | Step back through editor checkpoints |
+| `ALT+S → R` | Redo | Step forward again (an edit invalidates the redo) |
+| `ALT+S → A` | Append Stash | Append the stash text to the input (stash kept) |
+| `ALT+S → Y` | Copy Last Response | Copy the last assistant response to the system clipboard |
+| `ALT+S → K` | Add to Kanboard Backlog | Add the editor text to the project's kanboard backlog as a body-only task (attached file paths in the text are uploaded) |
 | `ALT+I` | Tab Insert | Insert literal tab character |
 
 ## Commands
@@ -32,36 +30,26 @@ Every action shows a brief success or error message in the status bar via `ctx.u
 
 ## How It Works
 
-### Registers
+### Stash
 
 - **Stash register**: 1 register for quick save/restore
-- **Numbered registers**: 10 registers (0-9) for stored text snippets
-- **Persistence**: Saved to `.unipi/config/input-shortcuts.json` (per-project, atomic writes)
+- **Persistence**: Saved to `.unipi/config/input-shortcuts.json` (per-project, atomic writes). Files written by older versions (with ten numbered registers 0-9) still load; the register keys are ignored and dropped on the next save.
 
 ### Undo/Redo
 
-- In-memory ring buffer, max 50 snapshots per session
-- 500ms debounce on snapshot creation (prevents noise from rapid typing)
-- 1s throttle on undo (prevents rapid-fire undo)
-- Redo buffer cleared on new snapshot
+- Linear checkpoint history, O(1) amortized per record
+- A typing burst records the editor text exactly twice — before the first keystroke and after the last (burst closes after 600ms of quiet, and long bursts split every ~2s) — so undo works from the very first keystroke without reading the editor on every keypress
+- At most 100 checkpoints / 2M characters in memory (oldest evicted first)
+- An edit after an undo invalidates the redo; undoing captures un-flushed typing first
 - Not persisted across sessions
 
-### Clipboard
+### Copy Last Response
 
-Cross-platform clipboard detection with automatic fallback:
+Uses pi's own cross-platform `copyToClipboard` (wl-copy / xclip / pbcopy / Windows / WSL / OSC 52 fallbacks) on the text of the last assistant response — the same text pi's `/copy` copies.
 
-| Platform | Read | Write |
-|----------|------|-------|
-| Linux (X11) | `xclip -selection clipboard -o` | `xclip -selection clipboard` |
-| Linux (alt) | `xsel --clipboard --output` | `xsel --clipboard --input` |
-| macOS | `pbpaste` | `pbcopy` |
-| Windows | `powershell Get-Clipboard` | `clip` / `powershell Set-Clipboard` |
+### Kanboard Backlog
 
-Detected tool is cached after first use. Returns graceful error if no clipboard tool is available.
-
-### Thinking Toggle
-
-Cycles through Pi's thinking levels: off → low → medium → high → xhigh → off.
+The K chord hands the editor text to `globalThis.__unipi_kanboard_api.captureToBacklog()` (registered by `@pi-unipi/kanboard`): the text becomes a body-only Backlog task, and file paths in the text (pasted/dragged files and pasted images, which pi inserts as paths) are attached. Refuses with a status message when kanboard is not loaded or the folder is not onboarded.
 
 ## Configurables
 

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",