pi-ui-extend 1.0.40 → 1.0.42

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, formatSubagentLastActivity, 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,18 +106,20 @@ 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)}`;
+        const activity = formatSubagentLastActivity(agent.lastActivity);
+        const elapsed = formatElapsedSince(agent.startedAt, now);
+        const suffix = activity ? ` ${activity} ${elapsed}` : ` ${elapsed}`;
         const taskWidth = Math.max(8, rowWidth - stringDisplayWidth(prefix) - stringDisplayWidth(suffix));
         const taskText = ellipsizeDisplay(task, taskWidth);
         const text = `${prefix}${taskText}${suffix}`;
         lines.push({
             text: padOrTrimPlain(text, width),
             colorOverride: colors.muted,
-            segments: subagentPanelLineSegments({ text, icon, agentId: agent.id, model, taskText, prefix, runLabel, status: agent.status }, colors),
+            segments: subagentPanelLineSegments({ text, icon, agentId: agent.id, model, taskText, prefix, runLabel, activity, elapsed, status: agent.status }, colors),
             target,
         });
     }
@@ -126,20 +128,27 @@ 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;
     const suffixStart = taskStart + input.taskText.length;
+    const elapsedStart = input.text.length - input.elapsed.length;
+    const activityStart = input.activity ? elapsedStart - input.activity.length - 1 : -1;
     return [
         ...(runLabelStart >= 0 ? [{ start: runLabelStart, end: runLabelStart + input.runLabel.length, foreground: colors.warning }] : []),
         { start: iconStart, end: iconStart + input.icon.length, foreground: subagentStatusColor(input.status, colors), bold: true },
         { start: nameStart, end: nameStart + input.agentId.length, foreground: colors.accent, bold: true },
         { start: modelStart, end: modelStart + input.model.length, foreground: colors.info },
         { start: taskStart, end: suffixStart, foreground: colors.muted },
-        { start: suffixStart, end: input.text.length, foreground: colors.muted },
+        { start: suffixStart, end: input.activity ? activityStart : input.text.length, foreground: colors.muted },
+        ...(input.activity ? [{ start: activityStart, end: activityStart + input.activity.length, foreground: colors.info }] : []),
+        ...(input.activity ? [{ start: activityStart + input.activity.length, end: input.text.length, foreground: colors.muted }] : []),
     ].filter((segment) => segment.start >= 0 && segment.end > segment.start);
 }
 function subagentStatusColor(status, colors) {

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/session-lifecycle-controller.d.ts

@@ -27,6 +27,7 @@ export type AppSessionLifecycleHost = {
     handleExtensionError(error: ExtensionError): void;
     handleSessionEvent(event: AgentSessionEvent): void;
     bindAgentPause(session: AgentSession): void;
+    contextInventoryText?(runtime: AgentSessionRuntime, heading: string): string;
     addEntry(entry: Entry): void;
     setStatus(status: string): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;

package/dist/app/session/session-lifecycle-controller.js

@@ -44,6 +44,12 @@ export class AppSessionLifecycleController {
                 await this.bindCurrentSession({ awaitExtensions: false });
             });
             await this.bindCurrentSession({ awaitExtensions: false });
+            if (runtime.session.messages.length === 0) {
+                await this.awaitCurrentSessionExtensions(runtime);
+                const text = this.host.contextInventoryText?.(runtime, `Empty tab ready. cwd=${runtime.cwd}`);
+                if (text)
+                    this.host.addEntry({ id: createId("system"), kind: "system", text });
+            }
             if (runtime.modelFallbackMessage) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
             }

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

@@ -43,6 +43,7 @@ export type AppTabsControllerHost = {
     restoreAutoUserMessages?(messages: readonly SubmittedUserMessage[]): void;
     captureDeferredUserMessages?(): readonly SubmittedUserMessage[];
     restoreDeferredUserMessages?(messages: readonly SubmittedUserMessage[]): void;
+    contextInventoryText?(runtime: AgentSessionRuntime, heading: string): string;
     addEntry(entry: Entry): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
@@ -184,13 +185,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;
 }

package/dist/app/session/tabs-controller.js

@@ -350,6 +350,12 @@ export class AppTabsController {
         this.scheduleProjectSessionRetention();
         this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(restoredRuntime, generation);
+        if (restoredRuntime.session.messages.length === 0) {
+            await this.host.awaitCurrentSessionExtensions?.(restoredRuntime);
+            const text = this.host.contextInventoryText?.(restoredRuntime, `Opened an empty tab. cwd=${restoredRuntime.cwd}`);
+            if (text)
+                this.host.addEntry({ id: createId("system"), kind: "system", text });
+        }
         this.scheduleRestoredTabTitleRefresh(restoredSessionPaths, generation);
     }
     openNewTab() {
@@ -436,6 +442,7 @@ export class AppTabsController {
         this.host.render();
         try {
             await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
+            await this.host.awaitCurrentSessionExtensions?.(newRuntime);
         }
         catch (error) {
             if (this.pendingActiveTabId === targetTab.id)
@@ -477,7 +484,12 @@ export class AppTabsController {
         this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(targetTab.id);
-        this.host.addEntry({ id: createId("system"), kind: "system", text: `Opened a new tab. cwd=${newRuntime.cwd}` });
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: this.host.contextInventoryText?.(newRuntime, `Opened a new tab. cwd=${newRuntime.cwd}`)
+                ?? `Opened a new tab. cwd=${newRuntime.cwd}`,
+        });
         if (newRuntime.modelFallbackMessage)
             this.host.addEntry({ id: createId("system"), kind: "system", text: newRuntime.modelFallbackMessage });
         for (const diag of newRuntime.diagnostics ?? []) {
@@ -571,6 +583,7 @@ export class AppTabsController {
         this.host.render();
         try {
             await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
+            await this.host.awaitCurrentSessionExtensions?.(newRuntime);
         }
         catch {
             this.pendingActiveTabId = undefined;
@@ -615,6 +628,11 @@ export class AppTabsController {
         void this.saveTabs();
         this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(newRuntime, generation);
+        if (newRuntime.session.messages.length === 0) {
+            const text = this.host.contextInventoryText?.(newRuntime, `Opened an empty tab. cwd=${newRuntime.cwd}`);
+            if (text)
+                this.host.addEntry({ id: createId("system"), kind: "system", text });
+        }
         return true;
     }
     forkSessionEntryInNewTab(entryId) {
@@ -1953,7 +1971,12 @@ export class AppTabsController {
             for (const session of sessions) {
                 if (keep.has(session.path))
                     continue;
-                await this.unlinkSessionAndDcpSidecar(session.path);
+                // Lifecycle state can change while retention is scanning. Re-check the
+                // current runtime/open tabs immediately before destructive work so a
+                // session that became live after the initial snapshot is not removed.
+                if (this.preservedSessionPaths().has(resolve(session.path)))
+                    continue;
+                await this.unlinkSessionFile(session.path);
             }
         }
         catch {
@@ -1964,31 +1987,17 @@ export class AppTabsController {
         }
     }
     /**
-     * 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.
      */
-    async unlinkSessionAndDcpSidecar(sessionPath) {
-        let sidecarPath;
-        const header = await readSessionHeader(sessionPath);
-        if (header?.type === "session" && typeof header.id === "string" && header.id) {
-            sidecarPath = join(dirname(sessionPath), "dcp-state", header.id.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json");
-        }
+    async unlinkSessionFile(sessionPath, unlinkFile = unlink) {
+        if (this.preservedSessionPaths().has(resolve(sessionPath)))
+            return;
         try {
-            await unlink(sessionPath);
+            await unlinkFile(sessionPath);
         }
         catch {
-            // Session retention must never interrupt the terminal UI.
-        }
-        if (sidecarPath) {
-            try {
-                await unlink(sidecarPath);
-            }
-            catch {
-                // Sidecar removal is best-effort; never interrupt the terminal UI.
-            }
+            return;
         }
     }
     preservedSessionPaths() {