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

package/packages/footer/src/rendering/icons.ts

@@ -35,13 +35,8 @@ export interface IconSet {
   directory: string;
 
   // Compactor segments
-  sessionEvents: string;
-  compactions: string;
-  tokensSaved: string;
-  compressionRatio: string;
   indexedDocs: string;
   sandboxRuns: string;
-  searchQueries: string;
 
   // Memory segments
   projectCount: string;
@@ -106,13 +101,8 @@ export const NERD_ICONS: IconSet = {
   thinkingLevel:   "\uF400", // 
 
   // Compactor
-  sessionEvents:   "\uEA86", // 
-  compactions:     "\u{F0C8F}", // 󰲏
-  tokensSaved:     "\uF155", //  (kept — missing from customization)
-  compressionRatio:"\u{F0C8F}", // 󰲏
   indexedDocs:     "\u{F0219}", // 󰈙
   sandboxRuns:     "\uF233", // 
-  searchQueries:   "\uF002", // 
 
   // Memory
   projectCount:    "\uEE9C", // 
@@ -177,13 +167,8 @@ export const EMOJI_ICONS: IconSet = {
   directory:       "📁",
 
   // Compactor
-  sessionEvents:   "📈",
-  compactions:     "🗜️",
-  tokensSaved:     "💲",
-  compressionRatio:"📐",
   indexedDocs:     "📑",
   sandboxRuns:     "▶️",
-  searchQueries:   "🔍",
 
   // Memory
   projectCount:    "🧠",
@@ -248,13 +233,8 @@ export const TEXT_ICONS: IconSet = {
   directory:       "DIR",
 
   // Compactor
-  sessionEvents:   "EVT",
-  compactions:     "CMP",
-  tokensSaved:     "SVD",
-  compressionRatio:"RAT",
   indexedDocs:     "IDX",
   sandboxRuns:     "SBX",
-  searchQueries:   "QRY",
 
   // Memory
   projectCount:    "MEM",

package/packages/footer/src/segments/compactor.ts

@@ -1,23 +1,16 @@
 /**
- * @pi-unipi/footer — Compactor segments
+ * @pi-unipi/footer — Compactor segment
  *
- * Segment renderers for the compactor group: session_events, compactions,
- * tokens_saved, compression_ratio, sandbox_runs, search_queries.
+ * One dense, icon-free segment, shown once the session has compacted:
  *
- * Data sourced from piContext.sessionManager (live session data).
- * Segments without a reliable data source are hidden (visible: false)
- * rather than showing a placeholder like "—".
+ *   cmp 4× 39k→13k · 3m
+ *
+ * count, tokens before → after across all compactions, time since the last.
+ * Read from the session branch (Pi's compaction entries).
  */
 
 import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
-import { applyColor, mutedPlaceholder } from "../rendering/theme.js";
-import { getIcon } from "../rendering/icons.js";
-import { isSegmentEnabled } from "../config.js";
-
-function withIcon(segmentId: string, text: string): string {
-  const icon = getIcon(segmentId);
-  return icon ? `${icon} ${text}` : text;
-}
+import { applyColor } from "../rendering/theme.js";
 
 function formatTokens(n: number): string {
   if (n < 1000) return n.toString();
@@ -26,149 +19,66 @@ function formatTokens(n: number): string {
   return `${(n / 1000000).toFixed(1)}M`;
 }
 
-/** Hidden segment — no reliable data source available */
-function hidden(): RenderedSegment {
-  return { content: "", visible: false };
+function ago(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return "now";
+  if (s < 3600) return `${Math.round(s / 60)}m`;
+  if (s < 86400) return `${Math.round(s / 3600)}h`;
+  return `${Math.round(s / 86400)}d`;
 }
 
-/** Safely extract sessionManager from piContext */
-function getSessionManager(ctx: FooterSegmentContext): any {
-  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
-  return piCtx?.sessionManager as any | undefined;
+/** Tokens left after a compaction: our recorded estimate, else the summary size. */
+function tokensAfterOf(entry: any, before: number): number {
+  const recorded = Number(entry?.details?.tokensAfter ?? 0);
+  if (recorded > 0) return Math.min(recorded, before);
+  const summaryChars = typeof entry?.summary === "string" ? entry.summary.length : 0;
+  return Math.min(before, Math.ceil(summaryChars / 4));
 }
 
-/** Get all session events from sessionManager branch */
-function getSessionEvents(ctx: FooterSegmentContext): any[] {
-  const sm = getSessionManager(ctx);
-  if (!sm || typeof sm.getBranch !== "function") return [];
+function branchOf(ctx: FooterSegmentContext): any[] {
+  const sm = (ctx.piContext as Record<string, unknown> | undefined)?.sessionManager as any;
   try {
-    return sm.getBranch() ?? [];
+    return typeof sm?.getBranch === "function" ? (sm.getBranch() ?? []) : [];
   } catch {
     return [];
   }
 }
 
-function renderSessionEventsSegment(ctx: FooterSegmentContext): RenderedSegment {
-  const events = getSessionEvents(ctx);
-  const count = events.length;
-  if (count === 0) {
-    if (isSegmentEnabled("compactor", "session_events")) {
-      return { content: mutedPlaceholder(withIcon("sessionEvents", "0")), visible: true };
-    }
-    return hidden();
+export function compactionSummary(branch: readonly any[], now = Date.now()): { count: number; before: number; after: number; lastAt?: number } {
+  let count = 0;
+  let before = 0;
+  let after = 0;
+  let lastAt: number | undefined;
+  for (const e of branch) {
+    if (e?.type !== "compaction") continue;
+    count++;
+    const b = Number(e.tokensBefore ?? 0);
+    before += b;
+    after += tokensAfterOf(e, b);
+    const at = Date.parse(e.timestamp ?? "");
+    if (Number.isFinite(at) && at <= now) lastAt = at;
   }
-
-  const content = withIcon("sessionEvents", `${count}`);
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
+  return { count, before, after, ...(lastAt != null ? { lastAt } : {}) };
 }
 
 function renderCompactionsSegment(ctx: FooterSegmentContext): RenderedSegment {
-  // Count compaction entries in the session events
-  const events = getSessionEvents(ctx);
-  let compactionCount = 0;
-  for (const e of events) {
-    if (!e || typeof e !== "object") continue;
-    if (e.type === "compaction" || e.type === "compacted") {
-      compactionCount++;
-    }
-  }
-  if (compactionCount === 0) {
-    if (isSegmentEnabled("compactor", "compactions")) {
-      return { content: mutedPlaceholder(withIcon("compactions", "0")), visible: true };
-    }
-    return hidden();
-  }
-
-  const content = withIcon("compactions", `${compactionCount}`);
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
-}
-
-function renderTokensSavedSegment(ctx: FooterSegmentContext): RenderedSegment {
-  // Sum tokens saved from compaction entries.
-  // Pi's CompactionEntry has tokensBefore (total tokens before compaction).
-  // Compaction keeps ~10-15% of context, so tokens saved ≈ tokensBefore × 0.85.
-  const events = getSessionEvents(ctx);
-  let tokensSaved = 0;
-  let hasCompaction = false;
-  for (const e of events) {
-    if (!e || typeof e !== "object") continue;
-    if (e.type === "compaction") {
-      hasCompaction = true;
-      const tokensBefore = Number(e.tokensBefore ?? 0);
-      // Estimate tokens kept at ~12% (compaction summary + recent messages)
-      const tokensAfter = Math.round(tokensBefore * 0.12);
-      tokensSaved += Math.max(0, tokensBefore - tokensAfter);
-    }
-  }
-  if (!hasCompaction || tokensSaved === 0) return hidden();
-
-  const content = withIcon("tokensSaved", formatTokens(tokensSaved));
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
-}
-
-function renderCompressionRatioSegment(ctx: FooterSegmentContext): RenderedSegment {
-  // Calculate compression ratio from Pi's CompactionEntry.tokensBefore.
-  // Compaction keeps ~12% of context, giving ~8:1 compression.
-  const events = getSessionEvents(ctx);
-  let totalBefore = 0;
-  let totalAfter = 0;
-  for (const e of events) {
-    if (!e || typeof e !== "object") continue;
-    if (e.type === "compaction") {
-      const before = Number(e.tokensBefore ?? 0);
-      if (before > 0) {
-        totalBefore += before;
-        totalAfter += Math.round(before * 0.12);
-      }
-    }
-  }
-  if (totalBefore === 0 || totalAfter === 0) return hidden();
-
-  const ratio = totalBefore / totalAfter;
-  const content = withIcon("compressionRatio", `${ratio.toFixed(1)}x`);
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
-}
-
-function renderSandboxRunsSegment(ctx: FooterSegmentContext): RenderedSegment {
-  // Count sandbox events from session manager branch
-  const events = getSessionEvents(ctx);
-  let sandboxCount = 0;
-  for (const e of events) {
-    if (!e || typeof e !== "object") continue;
-    // Count tool calls that are sandbox/execute tools
-    const name = String((e as any).name ?? "").toLowerCase();
-    if (name.includes("sandbox") || name.includes("ctx_execute") || name === "execute") {
-      sandboxCount++;
-    }
-  }
-  if (sandboxCount === 0) return hidden();
-
-  const content = withIcon("sandboxRuns", `${sandboxCount}`);
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
-}
-
-function renderSearchQueriesSegment(ctx: FooterSegmentContext): RenderedSegment {
-  // Count search events from session manager branch
-  const events = getSessionEvents(ctx);
-  let searchCount = 0;
-  for (const e of events) {
-    if (!e || typeof e !== "object") continue;
-    const name = String((e as any).name ?? "").toLowerCase();
-    if (name.includes("search") || name.includes("ctx_search")) {
-      searchCount++;
-    }
-  }
-  if (searchCount === 0) return hidden();
-
-  const content = withIcon("searchQueries", `${searchCount}`);
-  return { content: applyColor("compactor", content, ctx.theme, ctx.colors), visible: true };
+  const s = compactionSummary(branchOf(ctx));
+  if (s.count === 0) return { content: "", visible: false };
+  const dim = (t: string) => `\x1b[2m${t}\x1b[22m`;
+  const sizes = s.before > 0 ? ` ${formatTokens(s.before)}→${formatTokens(s.after)}` : "";
+  const age = s.lastAt != null ? dim(` · ${ago(Date.now() - s.lastAt)}`) : "";
+  const content = `${dim("cmp")} ${applyColor("compactor", `${s.count}×${sizes}`, ctx.theme, ctx.colors)}${age}`;
+  return { content, visible: true };
 }
 
 export const COMPACTOR_SEGMENTS: FooterSegment[] = [
-  { id: "session_events", label: "Session Events", shortLabel: "EVT", description: "Number of session events", zone: "center", render: renderSessionEventsSegment, defaultShow: true },
-  { id: "compactions", label: "Compactions", shortLabel: "CMP", description: "Number of context compactions", zone: "center", render: renderCompactionsSegment, defaultShow: true },
-  { id: "tokens_saved", label: "Tokens Saved", shortLabel: "SVD", description: "Tokens saved by compaction", zone: "center", render: renderTokensSavedSegment, defaultShow: true },
-  { id: "compression_ratio", label: "Compression Ratio", shortLabel: "RAT", description: "Last compaction compression ratio", zone: "center", render: renderCompressionRatioSegment, defaultShow: false },
-  { id: "sandbox_runs", label: "Sandbox Runs", shortLabel: "SBX", description: "Number of sandbox code runs", zone: "center", render: renderSandboxRunsSegment, defaultShow: false },
-  { id: "search_queries", label: "Search Queries", shortLabel: "QRY", description: "Number of search queries", zone: "center", render: renderSearchQueriesSegment, defaultShow: false },
+  {
+    id: "compactions",
+    label: "Compactions",
+    shortLabel: "CMP",
+    description: "Compactions this session: count, tokens before → after, time since the last (hidden until the first)",
+    zone: "center",
+    render: renderCompactionsSegment,
+    defaultShow: true,
+  },
 ];

package/packages/footer/src/segments/status-ext.ts

@@ -23,7 +23,6 @@ const STATUS_DISPLAY: Record<string, { short: string; segmentId: string }> = {
   workflow: { short: "WF", segmentId: "currentCommand" },
   ralph: { short: "RL", segmentId: "activeLoops" },
   memory: { short: "MEM", segmentId: "projectCount" },
-  compactor: { short: "CMP", segmentId: "compactions" },
   mcp: { short: "MCP", segmentId: "serversTotal" },
   notify: { short: "NTF", segmentId: "platformsEnabled" },
   kanboard: { short: "KB", segmentId: "docsCount" },

package/packages/fusion/README.md

@@ -23,7 +23,7 @@ pi's extension and RPC APIs natively.
 │  Model key  openrouter/deepseek/deepseek-v4.1-flash                  │
 │                                                                       │
 │  ✱ New  ✱ Promotion  ✱ Beta · Pairs frontier intelligence with cost-efficient execution │
-│↑↓ select · tab lead · ←→ effort · ↵ confirm · esc cancel              │
+│↑↓ select · tab lead · ←→ lead effort · space → side · ↵ confirm · esc │
 ╰───────────────────────────────────────────────────────────────────────╯
 ```
 
@@ -41,6 +41,11 @@ pi's extension and RPC APIs natively.
 - **`tab`** on the Fusion row cycles focus: effort → lead → sidekick
   (`shift+tab` reverses). Focused columns open an inline dropdown over the
   preset lists; `↵` applies, `esc` collapses.
+- **`space`** on the Fusion row toggles which side `←`/`→` adjusts: lead
+  effort (default) ↔ sidekick effort. The row shows both levels (`Lead … ▸High`,
+  `Sidekick … Low` — `▸` marks the side `←`/`→` moves) and the hint line names
+  the target. A changed sidekick effort reaches a running sidekick over rpc
+  (`set_thinking_level`) and lands in the spawn args for the next process.
 - **Price panel**: the highlighted model's blended price is marked on a
   logarithmic red→orange→yellow→green→cyan→blue→violet slider. Fusion shows
   `Input`, `Cached input`, `Output`, `Sidekick input`, `Sidekick cached input`,
@@ -109,9 +114,14 @@ notification and any follow-up turn, so the report is not released at an
 intermediate checkpoint. If a prompt arrives while the child is processing,
 Fusion retries it once with pi's `followUp` streaming behavior. Sidekick work
 renders as ordinary tool activity — handoff ids, `agent_id`, and
-`read_subagent` protocol text never reach the terminal. Sidekick output keeps
-that same format on the main surface, marked as sidekick-origin by a `▍` rail.
-While the sidekick works and the lead's turn is over, an animated
+`read_subagent` protocol text never reach the terminal. Sidekick steps draw in
+the active render style — mcode rows in simple, `◆` + guttered output in
+advanced, pi's own finished-call card (its exported `ToolExecutionComponent` +
+per-tool defs) in regular — each line marked as sidekick-origin by a `▏` rail
+on the custom-message background. Consecutive steps join into one rail block
+with no blank separator; in simple mode a run of tool steps draws the same
+`├…├…└` tree the lead's tools get, and prose steps stay `●`-anchored inside
+the block. While the sidekick works and the lead's turn is over, an animated
 `sidekick working` line above the editor shows the live tool count and elapsed
 time until the report lands.
 `read_subagent({agent_id?, block?, timeout?})` reads or waits for a handoff.

package/packages/fusion/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/fusion",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Devin-style model picker, fusion presets (lead + sidekick), and Local Fusion runtime for UniPi",
   "type": "module",
   "main": "src/index.ts",
@@ -32,8 +32,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.2",
-    "@pi-unipi/subagents": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21",
+    "@pi-unipi/subagents": "3.0.0-alpha.21",
+    "@pi-unipi/utility": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.87.1",

package/packages/fusion/src/child-args.ts

@@ -0,0 +1 @@
+export { leadExtensionArgs } from "@pi-unipi/core/child-agent.js";

package/packages/fusion/src/index.ts

@@ -16,13 +16,14 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { AutocompleteProvider, AutocompleteSuggestions } from "@earendil-works/pi-tui";
-import { createSpinnerLine, registerCommandRunner, setHerdrWorking, setSharedFusionStatus, stateDir, UNIPI_PREFIX, HUB_OVERLAY_OPTIONS } from "@pi-unipi/core";
+import { createSpinnerLine, harnessToolResultDetails, registerCommandRunner, setHerdrWorking, setSharedFusionStatus, stateDir, UNIPI_PREFIX, HUB_OVERLAY_OPTIONS, HUB_PICKER_OVERLAY_OPTIONS } from "@pi-unipi/core";
 import { join } from "node:path";
 import {
   effortLabel,
   globalPresetPath,
   isEffortLevel,
   loadPreset,
+  mirrorStartupFromPi,
   modelKey,
   pushRecent,
   saveCuration,
@@ -39,7 +40,10 @@ import { estimateSavings } from "./savings.js";
 import { EDIT_NUDGE, bashNudge, leadPolicy, sidekickSystemPrompt, type FusionIdentity } from "./prompts.js";
 import { isTrivialShell, BASH_NUDGE_EVERY } from "./nudge.js";
 import { registerFusionTools } from "./tools.js";
-import { duration } from "./transcript.js";
+import { duration, renderSidekickStep } from "./transcript.js";
+import { persistDefaultModel, piSettingsPath } from "./pi-settings.js";
+import { ensureReadSubagentTool, setReadSubagentDemand } from "@pi-unipi/core/child-agent.js";
+import { readFileSync } from "node:fs";
 
 export const MODEL_COMMAND = `${UNIPI_PREFIX}model`;
 
@@ -125,6 +129,15 @@ export function createSidekickWakeLine(deps: {
 
 type Registry = { getAvailable(): Model<Api>[]; find(provider: string, id: string): Model<Api> | undefined };
 
+/** Keep /unipi:settings → Fusion → Startup showing pi's real default. */
+function mirrorStartup(cwd: string): void {
+  try {
+    mirrorStartupFromPi(cwd);
+  } catch {
+    /* display mirror only */
+  }
+}
+
 function registryOf(ctx: ExtensionContext): Registry | undefined {
   const r = (ctx as unknown as { modelRegistry?: Registry }).modelRegistry;
   return r && typeof r.getAvailable === "function" ? r : undefined;
@@ -133,7 +146,11 @@ function registryOf(ctx: ExtensionContext): Registry | undefined {
 /** Key-based lookup (provider ids can contain slashes, so splitModelKey+find is unreliable). */
 const modelBykey = new Map<string, Model<Api>>();
 function findModel(reg: Registry | undefined, key: string): Model<Api> | undefined {
-  if (modelBykey.size === 0 && reg) for (const m of reg.getAvailable()) modelBykey.set(modelKey(m), m);
+  // Refill on a miss too: providers (e.g. bridges) can register models after the first lookup.
+  if (!modelBykey.has(key) && reg) {
+    modelBykey.clear();
+    for (const m of reg.getAvailable()) modelBykey.set(modelKey(m), m);
+  }
   return modelBykey.get(key);
 }
 
@@ -184,6 +201,27 @@ export function createModelBoostProvider(current: AutocompleteProvider): Autocom
   };
 }
 
+export const FUSION_TOOLS = ["sidekick"] as const;
+
+/**
+ * Adds the fusion tools to pi's active set while Fusion is active, removes
+ * them otherwise — touching ONLY `sidekick`/`read_subagent`, never another
+ * module's tools. Compares against the live active set (pi rebuilds it on
+ * session changes), and skips `setActiveTools` when nothing would change.
+ */
+export function makeFusionToolSync(pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">): (want: boolean) => void {
+  return (want: boolean) => {
+    const current = pi.getActiveTools();
+    if (FUSION_TOOLS.every((tool) => current.includes(tool) === want)) return;
+    const set = new Set(current);
+    for (const tool of FUSION_TOOLS) {
+      if (want) set.add(tool);
+      else set.delete(tool);
+    }
+    pi.setActiveTools([...set]);
+  };
+}
+
 export default function fusionExtension(pi: ExtensionAPI): void {
   if (process.env.UNIPI_FUSION_CHILD === "1") return;
 
@@ -203,6 +241,16 @@ export default function fusionExtension(pi: ExtensionAPI): void {
     onHeld: (label) => setHerdrWorking(pi, "fusion-sidekick", label),
   });
 
+  const syncTools = makeFusionToolSync(pi);
+  // `read_subagent` presence is demand-driven across owners (core registry):
+  // fusion wants it only while a Fusion pair is active.
+  const syncFusionTools = () => {
+    const fusion = active?.kind === "fusion";
+    syncTools(fusion);
+    setReadSubagentDemand(pi, "fusion", fusion);
+  };
+  ensureReadSubagentTool(pi);
+
   function identity(ctx: ExtensionContext): FusionIdentity {
     const reg = registryOf(ctx);
     const names = (k: string) => findModel(reg, k)?.name || splitModelKey(k)?.id || k;
@@ -232,6 +280,8 @@ export default function fusionExtension(pi: ExtensionAPI): void {
       // the working lead lit, the sidekick muted.
       setSharedFusionStatus({
         leadName: names(active.lead),
+        leadKey: active.lead,
+        sidekickKey: active.sidekick,
         leadEffort: active.leadEffort ?? "",
         sidekickName: names(active.sidekick),
         sidekickEffort: active.sidekickEffort ?? "",
@@ -268,6 +318,17 @@ export default function fusionExtension(pi: ExtensionAPI): void {
         sessionFile: sidekickSessionPath(leadSessionId(ctx)),
         systemPrompt: sidekickSystemPrompt(identity(ctx)),
         onProgress: () => publishStatusLater(),
+        onStep: (step) => {
+          try {
+            // Group per handoff so resumed handoffs render as separate panels
+            // even with no lead turn between them; old entries without a
+            // group fall back to the shared "sidekick" run.
+            const handoffId = runtime?.latest()?.id;
+            pi.appendEntry("sidekick-step", { ...step, group: `sidekick:${handoffId ?? "default"}`, label: "Sidekick" });
+          } catch {
+            /* entry rendering never affects the handoff */
+          }
+        },
       });
     }
     return runtime;
@@ -293,6 +354,14 @@ export default function fusionExtension(pi: ExtensionAPI): void {
     return `Sidekick tokens: in ${String(runtime.usage.input)} · out ${String(runtime.usage.output)} · cached ${String(runtime.usage.cacheRead)} · cache write ${String(runtime.usage.cacheWrite)}\nSidekick cost: $${savings.sidekickUsd.toFixed(2)} · at lead prices: $${savings.atLeadUsd.toFixed(2)} · saved: $${savings.savedUsd.toFixed(2)}\nHandoffs: ${String(runtime.reports.size)} · runtime alive: ${String(runtime.isAlive())} · busy: ${String(runtime.isBusy())}${pricing}`;
   }
 
+  pi.registerEntryRenderer("sidekick-step", (entry: { data?: { group?: string; label?: string } }, options: { expanded?: boolean }, theme) =>
+    renderSidekickStep(
+      entry.data as never,
+      options.expanded === true,
+      theme as never,
+      { group: entry.data?.group ?? "sidekick", label: entry.data?.label },
+    ));
+
   registerFusionTools(pi, {
     getRuntime,
     onReport: (ctx) => publishStatusLater(ctx),
@@ -304,7 +373,19 @@ export default function fusionExtension(pi: ExtensionAPI): void {
     description: "Estimated Fusion savings (sidekick tokens priced at lead rates)",
     handler: async (_args, ctx) => ctx.ui.notify(savingsStats(ctx), "info"),
   });
-  pi.on("before_agent_start", (event, ctx) => active?.kind === "fusion" ? { systemPrompt: `${event.systemPrompt}\n\n${leadPolicy(identity(ctx))}` } : undefined);
+  // Lead policy rides as a named system-prompt SECTION so pi records the
+  // section diff in the transcript (docs/extensions.md prefers sections over
+  // replacing `systemPrompt`, which nukes the cached prefix). The section is
+  // present only while Fusion is active.
+  pi.on("before_agent_start", (event, ctx) => {
+    syncFusionTools(); // safety net: re-sync after any module re-juggled tools
+    if (active?.kind === "fusion") {
+      event.systemPromptOptions.sections["fusion-lead-policy"] = leadPolicy(identity(ctx));
+    } else {
+      delete event.systemPromptOptions.sections["fusion-lead-policy"];
+    }
+    return undefined;
+  });
   pi.on("turn_start", () => {
     editNudgedThisTurn = false;
   });
@@ -324,16 +405,34 @@ export default function fusionExtension(pi: ExtensionAPI): void {
     if (toolName === "edit" || toolName === "write") {
       if (editNudgedThisTurn) return;
       editNudgedThisTurn = true;
-      return { content: [...event.content, { type: "text" as const, text: EDIT_NUDGE }] };
+      return {
+        content: [...event.content, { type: "text" as const, text: EDIT_NUDGE }],
+        details: harnessToolResultDetails(
+          (event as { details?: unknown }).details,
+          { source: "Fusion", title: "Delegate edits", synopsis: "Direct edit instead of sidekick delegation", severity: "warning" },
+          "boundary",
+          EDIT_NUDGE,
+        ),
+      };
     }
     if (toolName !== "bash") return;
     const command = typeof event.input.command === "string" ? event.input.command : "";
     if (isTrivialShell(command)) return;
     bashStreak += 1;
     if (bashStreak < BASH_NUDGE_EVERY) return;
-    const content = [...event.content, { type: "text" as const, text: bashNudge(bashStreak) }];
+    const annotation = bashNudge(bashStreak);
+    const synopsis = "Non-trivial shell work since last handoff";
+    const content = [...event.content, { type: "text" as const, text: annotation }];
     bashStreak = 0;
-    return { content };
+    return {
+      content,
+      details: harnessToolResultDetails(
+        (event as { details?: unknown }).details,
+        { source: "Fusion", title: "Delegate shell work", synopsis, severity: "warning" },
+        "boundary",
+        annotation,
+      ),
+    };
   });
 
   async function applyResult(ctx: ExtensionContext, result: PickerResult, preset: FusionPreset, loaded: { globalPath: string; projectPath: string; hasProjectLayer: boolean }): Promise<void> {
@@ -352,6 +451,16 @@ export default function fusionExtension(pi: ExtensionAPI): void {
       return;
     }
     if (!samePair) stopRuntime();
+    else if (
+      result.type === "fusion" &&
+      active?.kind === "fusion" &&
+      active.sidekickEffort !== result.sidekickEffort
+    ) {
+      // Same pair, new sidekick strength: a live child gets it over rpc
+      // (set_thinking_level); the value also lands in the spawn args for the
+      // next process start.
+      runtime?.setThinking(result.sidekickEffort);
+    }
     const effort = result.type === "single" ? result.effort : result.leadEffort;
     try {
       pi.setThinkingLevel(effort);
@@ -382,6 +491,7 @@ export default function fusionExtension(pi: ExtensionAPI): void {
       });
     }
     saveRuntimeState(loaded.globalPath, { effort: result.effortMap, recent, active });
+    syncFusionTools();
     publishStatus(ctx);
     const label =
       result.type === "single"
@@ -410,6 +520,16 @@ export default function fusionExtension(pi: ExtensionAPI): void {
         return;
       }
       const currentKey = ctx.model ? modelKey(ctx.model) : undefined;
+      // pi's persisted startup default (settings.json) marks the `default` row.
+      let defaultKey: string | undefined;
+      try {
+        const raw = JSON.parse(readFileSync(piSettingsPath(), "utf8")) as { defaultProvider?: string; defaultModel?: string };
+        if (typeof raw.defaultProvider === "string" && typeof raw.defaultModel === "string") {
+          defaultKey = `${raw.defaultProvider}/${raw.defaultModel}`;
+        }
+      } catch {
+        /* no settings file yet */
+      }
       // Session truth wins over persisted state: if the user switched via pi's
       // own /model since, show that as the pinned row.
       if (active === undefined && preset.active !== undefined) active = preset.active;
@@ -430,14 +550,44 @@ export default function fusionExtension(pi: ExtensionAPI): void {
               recent: preset.recent,
               active,
               currentModelKey: currentKey,
+              defaultModelKey: defaultKey,
               effort: preset.effort,
               fallbackEffort,
             },
             theme: { fg: (c, s) => theme.fg(c as never, s), bold: (s) => theme.bold(s) },
             onDone: done,
+            onSetDefault: (r) => {
+              if (r.type === "cancelled") return;
+              const saveDefault = (key: string, effort: string): boolean => {
+                const parts = splitModelKey(key);
+                if (parts === undefined) {
+                  ctx.ui.notify(`Could not save default: bad model key ${key}`, "error");
+                  return false;
+                }
+                try {
+                  persistDefaultModel({ provider: parts.provider, model: parts.id, thinkingLevel: effort });
+                  return true;
+                } catch (error) {
+                  ctx.ui.notify(`Could not save default: ${error instanceof Error ? error.message : String(error)}`, "error");
+                  return false;
+                }
+              };
+              if (r.type === "single") {
+                if (saveDefault(r.model, r.effort)) ctx.ui.notify(`Default: ${r.model} · ${r.effort}`, "info");
+                mirrorStartup(cwd);
+              } else if (saveDefault(r.lead, r.leadEffort)) {
+                mirrorStartup(cwd);
+                saveRuntimeState(loaded.globalPath, {
+                  effort: r.effortMap,
+                  recent: preset.recent,
+                  active: { kind: "fusion", lead: r.lead, sidekick: r.sidekick, leadEffort: r.leadEffort, sidekickEffort: r.sidekickEffort },
+                });
+                ctx.ui.notify(`Default: Fusion (${r.lead} + ${r.sidekick})`, "info");
+              }
+            },
             onRenderRequest: () => tui.requestRender(),
           }),
-        HUB_OVERLAY_OPTIONS,
+        HUB_PICKER_OVERLAY_OPTIONS,
       );
       await applyResult(ctx, result, preset, loaded);
     },
@@ -485,6 +635,7 @@ export default function fusionExtension(pi: ExtensionAPI): void {
     bashStreak = 0;
     modelBykey.clear();
     active = loadPreset(ctx.cwd ?? process.cwd()).preset.active;
+    mirrorStartup(ctx.cwd ?? process.cwd());
     if (active?.kind === "fusion" && (!ctx.model || modelKey(ctx.model) !== active.lead)) {
       const leadKey = active.lead;
       const lead = findModel(registryOf(ctx), leadKey);
@@ -500,6 +651,7 @@ export default function fusionExtension(pi: ExtensionAPI): void {
         if (ctx.hasUI) ctx.ui.notify(`Fusion lead ${leadKey} unavailable — Fusion off`, "warning");
       }
     }
+    syncFusionTools();
     publishStatus(ctx);
     if (ctx.hasUI) ctx.ui.addAutocompleteProvider(createModelBoostProvider);
   });
@@ -517,6 +669,7 @@ export default function fusionExtension(pi: ExtensionAPI): void {
       active = { kind: "single", model: modelKey(event.model) };
       const loaded = loadPreset(ctx.cwd ?? process.cwd());
       saveRuntimeState(globalPresetPath(), { effort: loaded.preset.effort, recent: loaded.preset.recent, active });
+      syncFusionTools();
       publishStatus(ctx);
     }
   });