pi-ui-extend 1.0.39 → 1.0.41

package/README.md

@@ -140,7 +140,7 @@ Optional:
 - an audio recorder for dictation: SoX (`rec`/`sox`), `ffmpeg`, or `arecord` on Linux
 - `tmux` and `rsvg-convert` only if you want to regenerate README screenshots
 - Ollama with web search enabled for the bundled `web_search` and `web_fetch` tools
-- language servers for the LSP module
+- language servers for the LSP module (see [LSP setup](external/pi-tools-suite/README.md#lsp-setup) for install commands and ready-to-paste configs for popular servers, including Svelte, Vue, Go, clangd, Lua, and bash)
 
 ### One-shot use
 

package/dist/app/commands/command-registry.js

@@ -249,9 +249,9 @@ export function createSlashCommands(actions, host) {
         },
         {
             name: "delete",
-            description: "Delete the current (or specified) session file plus its sidecar DCP state",
+            description: "Delete the current (or specified) session file",
             kind: "builtin",
-            keywords: ["remove", "destroy", "purge", "session", "sidecar", "dcp"],
+            keywords: ["remove", "destroy", "purge", "session", "dcp"],
             allowArguments: true,
             run: (argumentsText) => actions.runDeleteCommand(argumentsText),
         },

package/dist/app/commands/command-session-actions.d.ts

@@ -15,7 +15,6 @@ export declare class SessionCommandActions {
     runHotkeysCommand(): Promise<void>;
     runReloadCommand(): Promise<void>;
     runDeleteCommand(argumentsText: string): Promise<void>;
-    private removeDcpSidecarState;
     runNewSessionCommand(): Promise<void>;
     runCompactCommand(customInstructions?: string): Promise<void>;
     private piPackageRoot;

package/dist/app/commands/command-session-actions.js

@@ -342,7 +342,7 @@ export class SessionCommandActions {
             {
                 value: true,
                 label: `Yes, delete ${isCurrent ? "the current session" : basename(targetSessionFile)}`,
-                description: "This permanently removes the session file and any sidecar data. This cannot be undone.",
+                description: "This permanently removes the session file. This cannot be undone.",
                 variant: "error",
             },
             { value: false, label: "Cancel" },
@@ -356,11 +356,28 @@ export class SessionCommandActions {
         }
         this.host.setStatus("deleting session");
         this.host.render();
-        const sidecarRemoved = await this.removeDcpSidecarState(dirname(targetSessionFile), targetSessionId).catch(() => false);
-        await rm(targetSessionFile, { force: true }).catch(() => undefined);
         const deleteCurrent = isCurrent || targetSessionFile === currentSessionFile;
         if (deleteCurrent) {
+            // Do not race a final extension persistence operation with destructive
+            // session cleanup.
             await this.host.awaitCurrentSessionExtensions(runtime);
+            if (!isCommandRuntimeActive(this.host, runtime))
+                return;
+        }
+        try {
+            await rm(targetSessionFile, { force: true });
+        }
+        catch (error) {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Could not delete session file ${targetSessionFile}: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            this.host.toast.error("Session deletion failed");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        if (deleteCurrent) {
             const result = await runtime.newSession();
             if (!isCommandRuntimeActive(this.host, runtime))
                 return;
@@ -374,7 +391,7 @@ export class SessionCommandActions {
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
-                text: `Deleted session ${targetSessionId}. ${sidecarRemoved ? "Sidecar DCP state removed. " : ""}Started a new session. cwd=${runtime.cwd}`,
+                text: `Deleted session ${targetSessionId}. Started a new session. cwd=${runtime.cwd}`,
             });
             if (runtime.modelFallbackMessage)
                 this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
@@ -386,20 +403,12 @@ export class SessionCommandActions {
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
-                text: `Deleted session file ${targetSessionFile}${sidecarRemoved ? " and its sidecar DCP state" : ""}.`,
+                text: `Deleted session file ${targetSessionFile}.`,
             });
             this.host.setSessionStatus(runtime.session);
         }
         this.host.toast.success("Session deleted");
     }
-    async removeDcpSidecarState(sessionDir, sessionId) {
-        if (!sessionId)
-            return false;
-        const safeName = `${sessionId.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
-        const statePath = join(sessionDir, "dcp-state", safeName);
-        await rm(statePath, { force: true });
-        return true;
-    }
     async runNewSessionCommand() {
         const runtime = getIdleRuntime(this.host, "new");
         if (!runtime)

package/dist/app/icons.d.ts

@@ -33,6 +33,20 @@ declare const NERD_FONT_ICONS: {
     readonly toolPreviewTruncated: "⊞";
     readonly up: "↑";
     readonly down: "↓";
+    readonly agent: "󰚩";
+    readonly search: "󰍉";
+    readonly code: "󰅴";
+    readonly flask: "󰂓";
+    readonly globe: "󰇧";
+    readonly sparkles: "󰫢";
+    readonly brain: "󰧑";
+    readonly wrench: "󰖷";
+    readonly terminal: "󰆍";
+    readonly bug: "󰃤";
+    readonly book: "󰂺";
+    readonly eye: "󰈈";
+    readonly zap: "󰉁";
+    readonly rocket: "󰑣";
 };
 export type AppIconName = keyof typeof NERD_FONT_ICONS;
 export type AppIconMap = Record<AppIconName, string>;

package/dist/app/icons.js

@@ -44,6 +44,22 @@ const NERD_FONT_ICONS = {
     toolPreviewTruncated: "⊞",
     up: "↑",
     down: "↓",
+    // Sub-agent icons (agent .md frontmatter `icon:` names). Values are shared
+    // with the Pix Desktop lucide mapping in desktop/src/lib/agent-icons.ts.
+    agent: "\u{f06a9}", // nf-md-robot
+    search: "\u{f0349}", // nf-md-magnify
+    code: "\u{f0174}", // nf-md-code_tags
+    flask: "\u{f0093}", // nf-md-flask
+    globe: "\u{f01e7}", // nf-md-earth
+    sparkles: "\u{f0ae2}", // nf-md-star_four_points
+    brain: "\u{f09d1}", // nf-md-brain
+    wrench: "\u{f05b7}", // nf-md-wrench
+    terminal: "\u{f018d}", // nf-md-console
+    bug: "\u{f00e4}", // nf-md-bug
+    book: "\u{f00ba}", // nf-md-book
+    eye: "\u{f0208}", // nf-md-eye
+    zap: "\u{f0241}", // nf-md-flash
+    rocket: "\u{f0463}", // nf-md-rocket
 };
 const FALLBACK_ICONS = {
     alert: "⚠",
@@ -78,6 +94,23 @@ const FALLBACK_ICONS = {
     toolPreviewTruncated: "+",
     up: "↑",
     down: "↓",
+    // Sub-agent icon fallbacks (no icon-font codepoints; readable when the
+    // terminal font lacks Nerd Font glyphs). Emoji follow the existing fallback
+    // precedent (lightbulb, timerSand).
+    agent: "◇",
+    search: "⌕",
+    code: "{}",
+    flask: "∆",
+    globe: "⊕",
+    sparkles: "✦",
+    brain: "∞",
+    wrench: "⚙",
+    terminal: ">_",
+    bug: "🐛",
+    book: "▤",
+    eye: "◉",
+    zap: "↯",
+    rocket: "🚀",
 };
 export const APP_ICON_THEMES = {
     nerdFont: NERD_FONT_ICONS,

package/dist/app/rendering/conversation-tool-renderer.js

@@ -4,7 +4,7 @@ import { renderToolDisplay } from "../../tool-renderers/index.js";
 import { SUBAGENT_STATUSES, THINKING_TOOL_NAME, TODO_TOOL_NAME } from "../constants.js";
 import { attachImageClickTargets } from "../screen/image-click-targets.js";
 import { formatStructuredText } from "./message-content.js";
-import { formatSubagentTimestamp, isSubagentRunRenderDetails, isSubagentsToolName, subagentRunName, subagentStatusIcon, taskPreviewMap, } from "../subagents/subagents-model.js";
+import { formatSubagentTimestamp, isSubagentRunRenderDetails, isSubagentsToolName, subagentIcon, subagentRunName, taskPreviewMap, } from "../subagents/subagents-model.js";
 import { formatTodoTaskLine, isTodoDetails, visibleTodoTasks } from "../todo/todo-model.js";
 import { renderToolBlock } from "./tool-block-renderer.js";
 export function renderConversationToolEntry(entry, width, options) {
@@ -202,7 +202,7 @@ function subagentsDetailsText(details) {
     return lines.join("\n");
 }
 function formatSubagentToolLine(agent, preview) {
-    const parts = [subagentStatusIcon(agent.status), agent.status, agent.id];
+    const parts = [subagentIcon(preview), agent.status, agent.id];
     if (preview?.model)
         parts.push(`model:${preview.model}`);
     if (preview?.task)

package/dist/app/rendering/dcp-stats.d.ts

@@ -1,2 +1,7 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
-export declare function formatDcpStatsToast(session: AgentSession): string;
+type FormatDcpStatsOptions = {
+    manualModeBaseline?: boolean;
+    configPath?: string;
+};
+export declare function formatDcpStatsToast(session: AgentSession, options?: FormatDcpStatsOptions): string;
+export {};

package/dist/app/rendering/dcp-stats.js

@@ -1,14 +1,18 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
 import { normalizeToolName, parseArgsText } from "../../tool-renderers/utils.js";
 const NUDGE_TYPES = ["turn", "iteration", "context-soft", "context-strong"];
-export function formatDcpStatsToast(session) {
-    const latestState = resolveLatestDcpState(session);
-    const stats = collectDcpSessionStats(session, latestState);
-    const nudgeStats = collectDcpNudgeStats(session, latestState?.data);
+export function formatDcpStatsToast(session, options = {}) {
+    const branch = dcpStatsBranch(session);
+    const latestState = resolveJournalDcpState(branch);
+    const manualModeBaseline = options.manualModeBaseline ?? readDcpManualModeBaseline(session, options.configPath);
+    const stats = collectDcpSessionStats(session, latestState, branch, manualModeBaseline);
+    const nudgeStats = collectDcpNudgeStats(branch, latestState?.data);
     const activeBlocks = stats.activeBlocks ?? 0;
     const totalBlocks = stats.totalBlocks ?? stats.activeBlocks ?? 0;
-    const totalNudgeEvents = nudgeStats.emitted + nudgeStats.upgraded;
+    const totalNudgeEvents = nudgeStats.emitted + nudgeStats.reapplied + nudgeStats.upgraded;
     const activeAnchors = NUDGE_TYPES.reduce((sum, type) => sum + nudgeStats.activeByType[type], 0);
     const lines = [
         "DCP Session Statistics:",
@@ -19,7 +23,7 @@ export function formatDcpStatsToast(session) {
         `  State source: ${formatStateSource(stats.stateSource)}`,
         "",
         "Nudge telemetry:",
-        `  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.upgraded)} upgraded`,
+        `  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.reapplied)} reapplied, ${fmt(nudgeStats.upgraded)} upgraded`,
         `  By type: ${NUDGE_TYPES.map((type) => `${type}=${fmt(nudgeStats.byType[type])}`).join(", ")}`,
         `  Active anchors: ${fmt(activeAnchors)}${activeAnchors > 0 ? ` (${NUDGE_TYPES.map((type) => `${type}=${fmt(nudgeStats.activeByType[type])}`).join(", ")})` : ""}`,
         `  Cleared after compress: ${fmt(nudgeStats.clearedEvents)} time${nudgeStats.clearedEvents === 1 ? "" : "s"} (${fmt(nudgeStats.clearedAnchors)} anchor${nudgeStats.clearedAnchors === 1 ? "" : "s"})`,
@@ -32,7 +36,7 @@ export function formatDcpStatsToast(session) {
     ];
     return lines.join("\n");
 }
-function collectDcpSessionStats(session, latestState) {
+function collectDcpSessionStats(session, latestState, branch, manualModeBaseline) {
     const usage = session.getContextUsage();
     const stats = {
         runs: 0,
@@ -42,18 +46,16 @@ function collectDcpSessionStats(session, latestState) {
         summaryTokens: 0,
         prunedTools: 0,
         stateSource: latestState?.source ?? "tool-results",
+        ...(latestState ? { manualMode: manualModeBaseline } : {}),
         ...(usage?.tokens != null ? { contextTokens: usage.tokens } : {}),
         ...(usage?.contextWindow != null ? { contextWindow: usage.contextWindow } : {}),
         ...(usage?.percent != null ? { contextPercent: usage.percent } : {}),
     };
-    const branch = session.sessionManager.getBranch();
     if (latestState)
         applyDcpStateStats(stats, latestState.data);
     for (const entry of branch) {
         if (entry.type !== "message")
             continue;
-        if (latestState)
-            continue;
         const message = entry.message;
         if (message.role !== "toolResult")
             continue;
@@ -64,18 +66,24 @@ function collectDcpSessionStats(session, latestState) {
         const result = parseToolResultText(message.content);
         if (!result)
             continue;
-        stats.runs += 1;
-        stats.tokensSaved += numberValue(result.tokensSaved) ?? 0;
-        stats.totalPruneCount = Math.max(stats.totalPruneCount, numberValue(result.totalPruneCount) ?? 0);
-        stats.items += numberValue(result.itemCount) ?? sumDefined(numberValue(result.ranges), numberValue(result.messages)) ?? 0;
-        stats.summaryTokens += numberValue(result.totalSummaryTokens) ?? 0;
-        stats.prunedTools += numberValue(result.prunedTools) ?? 0;
-        const activeBlocks = numberValue(result.activeBlocks);
-        const totalBlocks = numberValue(result.totalBlocks);
-        if (activeBlocks != null)
-            stats.activeBlocks = activeBlocks;
-        if (totalBlocks != null)
-            stats.totalBlocks = totalBlocks;
+        if (result.idempotentReplay !== true) {
+            stats.runs += 1;
+            stats.tokensSaved += numberValue(result.tokensSaved) ?? 0;
+            stats.items += numberValue(result.itemCount) ?? sumDefined(numberValue(result.ranges), numberValue(result.messages)) ?? 0;
+            stats.summaryTokens += numberValue(result.totalSummaryTokens) ?? 0;
+        }
+        if (!latestState) {
+            stats.totalPruneCount = Math.max(stats.totalPruneCount, numberValue(result.totalPruneCount) ?? 0);
+            const prunedTools = numberValue(result.prunedTools);
+            if (prunedTools != null)
+                stats.prunedTools = prunedTools;
+            const activeBlocks = numberValue(result.activeBlocks);
+            const totalBlocks = numberValue(result.totalBlocks);
+            if (activeBlocks != null)
+                stats.activeBlocks = activeBlocks;
+            if (totalBlocks != null)
+                stats.totalBlocks = totalBlocks;
+        }
         const contextTokens = numberValue(result.contextTokens);
         const contextWindow = numberValue(result.contextWindow);
         const contextPercent = numberValue(result.contextPercent);
@@ -86,10 +94,17 @@ function collectDcpSessionStats(session, latestState) {
         if (stats.contextPercent == null && contextPercent != null)
             stats.contextPercent = contextPercent;
     }
+    if (latestState) {
+        // Journal state owns durable block/prune counts; successful compress tool
+        // results own operation gain because the journal intentionally stores only
+        // projection decisions rather than derived accounting snapshots.
+        stats.totalPruneCount = Math.max(stats.totalPruneCount, (stats.totalBlocks ?? 0) + stats.prunedTools);
+    }
     return stats;
 }
 function applyDcpStateStats(stats, data) {
     stats.tokensSaved = numberValue(data.tokensSaved) ?? stats.tokensSaved;
+    stats.tokensSaved += numberValue(data.prunedTokensSaved) ?? 0;
     stats.totalPruneCount = numberValue(data.totalPruneCount) ?? stats.totalPruneCount;
     const blocks = Array.isArray(data.compressionBlocks) ? data.compressionBlocks : undefined;
     if (blocks) {
@@ -101,16 +116,16 @@ function applyDcpStateStats(stats, data) {
     if (typeof data.manualMode === "boolean")
         stats.manualMode = data.manualMode;
 }
-function collectDcpNudgeStats(session, latestState) {
+function collectDcpNudgeStats(branch, latestState) {
     const stats = {
         emitted: 0,
+        reapplied: 0,
         upgraded: 0,
         clearedEvents: 0,
         clearedAnchors: 0,
         byType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
         activeByType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
     };
-    const branch = session.sessionManager.getBranch();
     if (latestState)
         applyActiveAnchorStats(stats, latestState);
     for (const entry of branch) {
@@ -118,9 +133,11 @@ function collectDcpNudgeStats(session, latestState) {
         if (!data)
             continue;
         const event = data.event;
-        if ((event === "emitted" || event === "upgraded") && isNudgeType(data.type)) {
+        if ((event === "emitted" || event === "reapplied" || event === "upgraded") && isNudgeType(data.type)) {
             if (event === "emitted")
                 stats.emitted += 1;
+            else if (event === "reapplied")
+                stats.reapplied += 1;
             else
                 stats.upgraded += 1;
             stats.byType[data.type] += 1;
@@ -142,6 +159,95 @@ function collectDcpNudgeStats(session, latestState) {
     }
     return stats;
 }
+function readDcpManualModeBaseline(session, configPath = join(homedir(), ".config", "pi", "pi-tools-suite.jsonc")) {
+    let enabled = false;
+    if (!existsSync(configPath))
+        return enabled;
+    try {
+        const parsed = parseJsonc(readFileSync(configPath, "utf8"));
+        if (!isRecord(parsed))
+            return enabled;
+        const dcp = parsed.dcp;
+        if (!isRecord(dcp))
+            return enabled;
+        const manualMode = dcp.manualMode;
+        if (isRecord(manualMode) && typeof manualMode.enabled === "boolean")
+            enabled = manualMode.enabled;
+        const overrides = dcp.modelOverrides;
+        if (!isRecord(overrides))
+            return enabled;
+        for (const override of matchingModelOverrides(overrides, dcpModelKeys(session))) {
+            const overrideManualMode = override.manualMode;
+            if (isRecord(overrideManualMode) && typeof overrideManualMode.enabled === "boolean") {
+                enabled = overrideManualMode.enabled;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return enabled;
+}
+function dcpModelKeys(session) {
+    const model = session.model;
+    const provider = normalizeModelKey(model?.provider);
+    const id = normalizeModelKey(model?.id);
+    return [provider && id ? `${provider}/${id}` : undefined, id].filter((key) => key !== undefined);
+}
+function matchingModelOverrides(overrides, modelKeys) {
+    const candidates = modelKeys.map(normalizeModelKey).filter((key, index, all) => key !== undefined && all.indexOf(key) === index);
+    const exact = new Map();
+    const wildcard = [];
+    for (const [rawKey, value] of Object.entries(overrides)) {
+        const key = normalizeModelKey(rawKey);
+        if (!key || !isRecord(value))
+            continue;
+        if (key.includes("*") || key.includes("?"))
+            wildcard.push([key, value]);
+        else
+            exact.set(key, value);
+    }
+    const bare = candidates.filter((candidate) => !candidate.includes("/"));
+    const full = candidates.filter((candidate) => candidate.includes("/"));
+    const matches = [];
+    for (const candidate of bare)
+        for (const [pattern, value] of wildcard)
+            if (!pattern.includes("/") && globMatches(pattern, candidate))
+                matches.push(value);
+    for (const candidate of bare) {
+        const value = exact.get(candidate);
+        if (value)
+            matches.push(value);
+    }
+    for (const candidate of full)
+        for (const [pattern, value] of wildcard)
+            if (pattern.includes("/") && globMatches(pattern, candidate))
+                matches.push(value);
+    for (const candidate of full) {
+        const value = exact.get(candidate);
+        if (value)
+            matches.push(value);
+    }
+    return matches;
+}
+function normalizeModelKey(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function globMatches(pattern, candidate) {
+    let source = "^";
+    for (const char of pattern) {
+        if (char === "*")
+            source += ".*";
+        else if (char === "?")
+            source += ".";
+        else
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+    return new RegExp(`${source}$`).test(candidate);
+}
 function applyActiveAnchorStats(stats, data) {
     stats.activeByType = { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 };
     const anchors = Array.isArray(data.nudgeAnchors) ? data.nudgeAnchors : [];
@@ -161,33 +267,95 @@ function applyActiveAnchorStats(stats, data) {
         };
     }
 }
-function resolveLatestDcpState(session) {
-    const sidecar = loadSidecarDcpState(session);
-    if (sidecar)
-        return { data: sidecar, source: "sidecar" };
-    return undefined;
-}
-function loadSidecarDcpState(session) {
-    const sessionManager = session.sessionManager;
-    const sessionDir = sessionManager.getSessionDir?.();
-    const sessionId = sessionManager.getSessionId?.();
-    if (!sessionDir || !sessionId)
+function resolveJournalDcpState(branch) {
+    const blocks = new Map();
+    const pruned = new Map();
+    let initialized = false;
+    let manualMode;
+    let nudgeAnchors = [];
+    let lastNudge;
+    for (const entry of branch) {
+        const operation = customEntryData(entry, "dcp-journal");
+        if (!operation || operation.schemaVersion !== 1)
+            continue;
+        if (operation.kind === "init") {
+            initialized = true;
+            continue;
+        }
+        if (!initialized || operation.kind !== "delta")
+            continue;
+        if (Array.isArray(operation.blocks)) {
+            for (const raw of operation.blocks) {
+                if (!isRecord(raw) || typeof raw.id !== "number")
+                    continue;
+                blocks.set(raw.id, { ...raw });
+            }
+        }
+        if (Array.isArray(operation.blockStates)) {
+            for (const raw of operation.blockStates) {
+                if (!isRecord(raw) || typeof raw.id !== "number")
+                    continue;
+                const block = blocks.get(raw.id);
+                if (!block)
+                    continue;
+                if (typeof raw.active === "boolean")
+                    block.active = raw.active;
+                if (typeof raw.deactivatedReason === "string")
+                    block.deactivatedReason = raw.deactivatedReason;
+            }
+        }
+        if (Array.isArray(operation.prunedTools)) {
+            for (const raw of operation.prunedTools) {
+                if (!isRecord(raw) || typeof raw.toolCallId !== "string")
+                    continue;
+                pruned.set(raw.toolCallId, {
+                    ...(typeof raw.reason === "string" ? { reason: raw.reason } : {}),
+                    tokenEstimate: Math.max(0, numberValue(raw.tokenEstimate) ?? 0),
+                });
+            }
+        }
+        if (typeof operation.manualMode === "boolean")
+            manualMode = operation.manualMode;
+        if (Array.isArray(operation.nudgeAnchors))
+            nudgeAnchors = operation.nudgeAnchors;
+        if (Object.prototype.hasOwnProperty.call(operation, "lastNudge"))
+            lastNudge = operation.lastNudge ?? undefined;
+    }
+    if (!initialized)
         return undefined;
+    return {
+        source: "journal",
+        data: {
+            compressionBlocks: [...blocks.values()],
+            prunedToolIds: [...pruned.keys()],
+            prunedTokensSaved: [...pruned.values()].reduce((sum, item) => sum + item.tokenEstimate, 0),
+            manualMode,
+            nudgeAnchors,
+            lastNudge,
+        },
+    };
+}
+function dcpStatsBranch(session) {
+    const manager = session.sessionManager;
     try {
-        const statePath = join(sessionDir, "dcp-state", safeSessionFileName(sessionId));
-        const parsed = JSON.parse(readFileSync(statePath, "utf8"));
-        return isRecord(parsed) ? parsed : undefined;
+        const full = manager.readFullBranchEntriesSync?.();
+        if (Array.isArray(full))
+            return full;
     }
     catch {
-        return undefined;
+        // Fall back to the manager's currently materialized branch below.
+    }
+    try {
+        const branch = manager.getBranch();
+        return Array.isArray(branch) ? branch : [];
+    }
+    catch {
+        return [];
     }
-}
-function safeSessionFileName(sessionId) {
-    return `${sessionId.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
 }
 function formatStateSource(source) {
-    if (source === "sidecar")
-        return "dcp-state sidecar";
+    if (source === "journal")
+        return "session journal";
     return "compress tool results";
 }
 function customEntryData(entry, customType) {

package/dist/app/rendering/editor-panels.js

@@ -1,8 +1,8 @@
 import { stringDisplayWidth } from "../../terminal-width.js";
 import { SUBAGENTS_WIDGET_MAX_ROWS } from "../constants.js";
-import { ellipsizeDisplay, padOrTrimPlain, wrapLine } from "./render-text.js";
+import { ellipsizeDisplay, padOrTrimPlain, sanitizeText, wrapLine } from "./render-text.js";
 import { thinkingLevelThemeColor } from "./status-line-renderer.js";
-import { activeSubagentStates, formatElapsedSince, formatSubagentsPanelStats, subagentModelThinkingLabel, subagentRunName, subagentStatusIcon, taskPreviewMap, } from "../subagents/subagents-model.js";
+import { activeSubagentStates, formatElapsedSince, formatSubagentsPanelStats, subagentIcon, subagentModelThinkingLabel, subagentRunName, taskPreviewMap, } from "../subagents/subagents-model.js";
 import { formatTodoPanelStats, formatTodoTaskLine, hasOpenTodoTasks, shiftSegmentsToSlice, todoTaskLineSegments, visibleTodoTaskRows, visibleTodoTasks, } from "../todo/todo-model.js";
 export function renderTodoPanel(details, expanded, width, colors) {
     if (!details)
@@ -106,8 +106,8 @@ export function renderSubagentsPanel(state, expanded, width, colors) {
     for (const visibleRun of visibleAgents) {
         const { agent, preview } = visibleRun;
         const model = subagentModelThinkingLabel(preview);
-        const task = preview?.task?.trim() || preview?.scope?.trim() || "task unavailable";
-        const icon = subagentStatusIcon(agent.status);
+        const task = singleLinePreview(preview?.task) || singleLinePreview(preview?.scope) || "task unavailable";
+        const icon = subagentIcon(preview);
         const runLabel = visibleRun.showRunLabel ? `${subagentRunName(visibleRun.runDir)} ` : "";
         const prefix = `${runLabel}${icon} ${agent.id} ${model} `;
         const suffix = ` ${formatElapsedSince(agent.startedAt, now)}`;
@@ -126,9 +126,12 @@ export function renderSubagentsPanel(state, expanded, width, colors) {
         lines.push({ text: padOrTrimPlain(`+${hidden} more`, width), variant: "muted", target });
     return lines;
 }
+function singleLinePreview(value) {
+    return value ? sanitizeText(value).replace(/\s+/gu, " ").trim() : "";
+}
 function subagentPanelLineSegments(input, colors) {
-    const iconStart = input.text.indexOf(input.icon);
     const runLabelStart = input.runLabel ? input.text.indexOf(input.runLabel) : -1;
+    const iconStart = input.runLabel.length;
     const nameStart = input.text.indexOf(input.agentId, iconStart + input.icon.length);
     const modelStart = input.text.indexOf(input.model, nameStart + input.agentId.length);
     const taskStart = input.prefix.length;

package/dist/app/session/lazy-session-manager.js

@@ -145,6 +145,14 @@ class LazySessionManager {
         const entries = await readAllSessionEntries(this.sessionFilePath);
         return branchEntries(entries, this.leafId ?? entries.at(-1)?.id);
     }
+    /**
+     * Explicit synchronous full-branch escape hatch for user-triggered diagnostics
+     * such as DCP statistics. Normal transcript rendering stays lazy; callers that
+     * opt into this method accept one full session hydration for exact branch data.
+     */
+    readFullBranchEntriesSync() {
+        return this.hydrate().getBranch();
+    }
     async readFullSessionEntries() {
         if (this.hydrated)
             return this.hydrated.getEntries();
@@ -320,10 +328,13 @@ class LazySessionManager {
         }
     }
     appendEntry(entry) {
+        // Persist first. If the append fails, the in-memory branch must remain
+        // unchanged; otherwise extensions that treat append success as a commit
+        // boundary can observe a phantom entry that never reached the JSONL file.
+        appendFileSync(this.sessionFilePath, `${JSON.stringify(entry)}\n`, "utf8");
         this.entries.push(entry);
         this.byId.set(entry.id, entry);
         this.leafId = entry.id;
-        appendFileSync(this.sessionFilePath, `${JSON.stringify(entry)}\n`, "utf8");
         return entry.id;
     }
     newEntry(type, payload) {

package/dist/app/session/tabs-controller.d.ts

@@ -184,13 +184,10 @@ export declare class AppTabsController {
     private prewarmTabs;
     private cleanupOldProjectSessions;
     /**
-     * Unlink a project session file and, best-effort, its DCP sidecar state.
-     * The sidecar path is derived from the session id in the first line of the
-     * `.jsonl` (mirrors the DCP module's `safeSessionFileName`), so retention
-     * never leaves orphan sidecars behind. Everything here is best-effort:
+     * Unlink a project session file. Everything here is best-effort:
      * session retention must never interrupt the terminal UI.
      */
-    private unlinkSessionAndDcpSidecar;
+    private unlinkSessionFile;
     private preservedSessionPaths;
     private maxProjectSessions;
 }