@chainingintention/pi-web-cn 2.202610.5 → 2.202611.1

package/dist/server/sessions/piSessionService.js

@@ -1,6 +1,11 @@
 import { parsePersistedChildSubsessionLink, parsePersistedParentSubsessionLink } from "./subsessionProvenance.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
+import { sessionNotificationSources } from "../../shared/sessionNotificationPresentation.js";
+import { runtimeActivityFallbackLabel } from "../../shared/sessionActivityPresentation.js";
+const STARTUP_PHASE_RUNTIME = "Starting the Pi session";
+const STARTUP_PHASE_EXTENSIONS = "Loading session extensions";
+const STARTUP_CONCURRENT_CATALOG_REFRESH = "provider model lists are refreshing";
 import { readSessionUiMetadata, requireSessionUiMetadata, SESSION_UI_METADATA_CUSTOM_TYPE } from "./sessionMetadata.js";
 import { UserFacingError, createTranslator, userFacingErrorMessage } from "../../shared/i18n.js";
 import { realpathSync, statSync } from "node:fs";
@@ -26,7 +31,7 @@ import { SessionActivityMarker } from "./sessionActivityMarker.js";
 import { projectSessionTree } from "./sessionTreeProjection.js";
 import { SessionArchiveStore } from "./sessionArchiveStore.js";
 import { findArchiveCandidateByExactId, planSessionArchiveTree } from "./sessionArchiveTree.js";
-import { fallbackSessionName, generateShortSessionName, requireInitialSessionName } from "./sessionNameGenerator.js";
+import { requireInitialSessionName } from "./sessionNameGenerator.js";
 import { computeEditPreview } from "./editPreview.js";
 import { attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
 import { loadEffectiveProjectAttachmentsConfig } from "../workspaces/projectPiWebConfig.js";
@@ -37,16 +42,18 @@ import { resolveWebProjectTrusted } from "./projectTrust.js";
 import { createPiSessionManagerGateway } from "./piSessionManagerGateway.js";
 import { SessionPinStore } from "./sessionPinStore.js";
 import { SessionActivityCoordinator } from "./sessionActivityCoordinator.js";
-import { searchSessionContent } from "./sessionContentSearch.js";
+import { compileSessionContentQuery, searchSessionContent } from "./sessionContentSearch.js";
 import { createLocalOnlyModelRuntime, modelRuntimeAuthPath } from "./authService.js";
 import { canonicalizeStoredCwd, cwdPathsEqual } from "../workingDirectory.js";
 import { clearSessionFileParent, readSessionHeaderSummary } from "./sessionFileHeader.js";
-import { isManagedAgentsFile, workbenchAccessHandle } from "../managementEmbed.js";
+import { assertManagedCwd, isManagedAgentsFile, workbenchAccessHandle } from "../managementEmbed.js";
 import { managementPrivilegeRequested, managementPrivileges, managementUsesNormalPermissions } from "../managementPrivileges.js";
 import { DEFAULT_EXTENSION_DIALOGS_TIMEOUT_MS, piWebDataDir } from "../../config.js";
 import { createScopedSettingsManager, resolveSettingsScopeDirectory } from "./projectSettingsScope.js";
 import { parseSessionDefaults, parseSessionDefaultsUpdate } from "../../shared/sessionDefaults.js";
 import { createAskUserToolDefinition } from "./askUserTool.js";
+import { createRequestHumanInterventionToolDefinition } from "./requestHumanInterventionTool.js";
+import { requestsHumanIntervention, SESSION_INTERVENTION_CUSTOM_TYPE, sessionInterventionRequired } from "./sessionIntervention.js";
 import { createAskUserOutcome, renderAskUserAnswersText, resolveAskUserRequest } from "./askUserDomain.js";
 import { createSubsessionCompletionDelivery } from "./subsessionCompletionDelivery.js";
 import { completionReceiptIds, persistedSubsessionCompletions, renderSubsessionCompletions, SUBSESSION_COMPLETION_ENTRY_TYPE, SUBSESSION_NOTIFICATION_CUSTOM_TYPE, SUBSESSION_RECEIPT_ENTRY_TYPE, SubsessionCompletionInbox } from "./subsessionCompletionInbox.js";
@@ -56,6 +63,7 @@ import { ExtensionDialogWaiters, effectiveExtensionDialogTimeoutMs, extensionDia
 import { createSpawnSessionToolDefinition } from "./spawnSessionTool.js";
 import { createSubsessionToolDefinitions } from "./spawnSubsessionTool.js";
 import { buildTranscriptView } from "./subsessionTranscript.js";
+import { createSendSessionMessageToolDefinition } from "./sendSessionMessageTool.js";
 import { planSessionCleanup, summarizeSessionCleanupExecution } from "./sessionCleanup.js";
 import { createManagedAgentToolOptions, createManagedBashToolDefinition, createManagedPythonToolDefinition } from "./managementAgentTools.js";
 import { PI_PERMISSION_SYSTEM_POLICY_AGENT_DIR, managementAgentToolNames, privilegedManagementToolNames, withRuntimeCreationEnvironment, writeManagementPermissionSystemPolicy } from "./managementPermissionSystem.js";
@@ -311,7 +319,8 @@ export function collectRuntimeWarnings(runtime) {
 /**
  * Verbatim TUI wording for the Anthropic subscription-auth billing notice. Kept
  * character-for-character in sync with `ANTHROPIC_SUBSCRIPTION_AUTH_WARNING` in
- * the SDK's interactive mode so the browser shows the same message the TUI does.
+ * the SDK's interactive mode as the wire fallback. Browser presentation metadata
+ * allows translation without matching this English string.
  */
 const ANTHROPIC_SUBSCRIPTION_AUTH_WARNING = "Anthropic subscription auth is active. Third-party harness usage draws from extra usage and is billed per token, not your Claude plan limits. Manage extra usage at https://claude.ai/settings/usage.";
 /** Mirror of the SDK TUI `isAnthropicSubscriptionAuthKey` (subscription API keys start with `sk-ant-oat`). */
@@ -352,6 +361,7 @@ export function anthropicSubscriptionWarning(session, authPath) {
     return {
         severity: "warning",
         message: ANTHROPIC_SUBSCRIPTION_AUTH_WARNING,
+        presentation: { kind: "anthropicSubscriptionAuth" },
         source: "anthropic",
         dismiss: { id: ANTHROPIC_EXTRA_USAGE_DISMISS_ID },
     };
@@ -438,11 +448,11 @@ async function createNormalPermissionSessionServices(options) {
     });
     return { services, projectTrustDiagnostics };
 }
-function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled = false, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = [], managementAllowPrivileged = false) {
+function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, managementModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled = false, workbench, logger = noopLogger, managementAudit, managementProjectIdForCwd, appendSystemPromptSections = [], managementAllowPrivileged = false, messaging) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, managementContext, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
         const scopedModelRuntime = managementContext === undefined ? await normalModelRuntimeForCwd(cwd) : await managementModelRuntime();
         if (managementContext !== undefined) {
-            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections)({
+            return createManagementRuntimeFactory(scopedModelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged, appendSystemPromptSections, messaging)({
                 cwd,
                 agentDir,
                 sessionManager,
@@ -454,6 +464,8 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
         }
         // Resource loaders may read process.env; wait for managed overrides to be restored.
         return withRuntimeCreationEnvironment({}, async () => {
+            const parentSessionFile = sessionManager.getHeader()?.parentSession;
+            const parentHeader = parentSessionFile === undefined ? undefined : await readSessionHeaderSummary(parentSessionFile);
             const projectTrustRequiring = hasTrustRequiringProjectResources(cwd);
             const settingsManager = await createScopedSettingsManager({
                 cwd,
@@ -473,7 +485,10 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
                 modelRuntime: scopedModelRuntime,
                 settingsManager,
                 projectTrustRequiring,
-                appendSystemPromptSections,
+                appendSystemPromptSections: [
+                    ...appendSystemPromptSections,
+                    ...(parentHeader === undefined ? [] : [`<pi_web_session_context>\nParent session ID: ${parentHeader.id}\n</pi_web_session_context>`]),
+                ],
                 eventBus,
                 mcpScope: { directory: mcpOAuthStorageDirectory(await resolveSettingsScope(cwd, "normal")) },
                 extensionFactories: [sessionDispatch, ...(subsessions === undefined ? [] : [createSubsessionCompletionDelivery(subsessions)])],
@@ -488,7 +503,7 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
             const resolvedDelegationToolsEnabled = delegationToolsEnabled
                 ?? await sessionAllowsDelegationTools(sessionManager, sessionManagers);
             dispatchEnabled = resolvedDelegationToolsEnabled;
-            const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUserEnabled);
+            const customTools = createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, spawn, subsessions, askUserEnabled, messaging);
             const result = await createAgentSessionFromServices({
                 services,
                 sessionManager,
@@ -505,7 +520,7 @@ function createDefaultRuntimeFactory(sessionEvents, normalModelRuntimeForCwd, ma
         });
     };
 }
-function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged = false, appendSystemPromptSections = []) {
+function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sessionManagers, spawn, subsessions, askUserEnabled, managementContext, workbench, logger, managementAudit, managementProjectIdForCwd, managementAllowPrivileged = false, appendSystemPromptSections = [], messaging) {
     return async ({ cwd, agentDir, sessionManager, sessionStartEvent, initialModel, initialThinkingLevel, delegationToolsEnabled }) => {
         const normalPermissions = managementUsesNormalPermissions(managementContext, { allowPrivileged: managementAllowPrivileged });
         const privileges = managementPrivileges(managementContext, { allowPrivileged: managementAllowPrivileged });
@@ -541,10 +556,16 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
         const scopedSpawn = spawn === undefined
             ? undefined
             : (input) => spawn({ ...input, managementContext });
+        const scopedMessaging = messaging === undefined ? undefined : {
+            send: (input) => messaging.send(input, managementContext),
+        };
         const scopedSubsessions = subsessions === undefined
             ? undefined
             : {
                 spawn: (input) => subsessions.spawn({ ...input, managementContext }),
+                archive: (parentSessionId, sessionId, parentSessionFile) => subsessions.archive(parentSessionId, sessionId, parentSessionFile, managementContext),
+                stop: (parentSessionId, sessionId, parentSessionFile) => subsessions.stop(parentSessionId, sessionId, parentSessionFile, managementContext),
+                resume: (parentSessionId, sessionId, prompt, parentSessionFile) => subsessions.resume(parentSessionId, sessionId, prompt, parentSessionFile, managementContext),
                 list: (parentSessionId, parentSessionFile) => subsessions.list(parentSessionId, parentSessionFile, managementContext),
                 join: (parentSessionId, parentSessionFile, toolCallId) => subsessions.join(parentSessionId, parentSessionFile, toolCallId, managementContext),
                 prepare: (parentSessionId, parentSessionFile) => subsessions.prepare(parentSessionId, parentSessionFile, managementContext),
@@ -560,6 +581,8 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
             ...(scopedSubsessions === undefined ? [] : [createSubsessionCompletionDelivery(scopedSubsessions)]),
         ];
         const controlledManagementTools = [
+            defineTool(createRequestHumanInterventionToolDefinition()),
+            ...(scopedMessaging === undefined ? [] : [defineTool(createSendSessionMessageToolDefinition(cwd, scopedMessaging))]),
             ...(resolvedDelegationToolsEnabled && scopedSpawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn: scopedSpawn }))] : []),
             ...(resolvedDelegationToolsEnabled && scopedSubsessions !== undefined ? createSubsessionToolDefinitions(cwd, scopedSubsessions).map((tool) => defineTool(tool)) : []),
             ...(askUserEnabled ? [createAskUserToolDefinition()] : []),
@@ -621,7 +644,7 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
                 ...(initialThinkingLevel === undefined ? {} : { initialThinkingLevel }),
             });
             services.diagnostics.push(...modelOptions.diagnostics);
-            const customTools = normalPermissions ? createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, scopedSpawn, scopedSubsessions, askUserEnabled) : [
+            const customTools = normalPermissions ? createPiWebCustomToolDefinitions(cwd, resolvedDelegationToolsEnabled, scopedSpawn, scopedSubsessions, askUserEnabled, scopedMessaging) : [
                 ...managedAgentToolDefinitions(cwd, createManagedAgentToolOptions(cwd)),
                 createManagedPythonToolDefinition(cwd, managementContext, { network: privileges.network }),
                 createManagedBashToolDefinition(cwd, managementContext, { network: privileges.network, hostFilesystem: privileges.bash }),
@@ -651,9 +674,11 @@ function createManagementRuntimeFactory(modelRuntime, resolveSettingsScope, sess
         });
     };
 }
-export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, askUserEnabled = false) {
+export function createPiWebCustomToolDefinitions(cwd, delegationEnabled, spawn, subsessions, askUserEnabled = false, messaging) {
     return [
         ...managedAgentToolDefinitions(cwd),
+        defineTool(createRequestHumanInterventionToolDefinition()),
+        ...(messaging === undefined ? [] : [defineTool(createSendSessionMessageToolDefinition(cwd, messaging))]),
         ...(delegationEnabled && spawn !== undefined ? [defineTool(createSpawnSessionToolDefinition(cwd, { spawn }))] : []),
         ...(delegationEnabled && subsessions !== undefined ? createSubsessionToolDefinitions(cwd, subsessions).map((tool) => defineTool(tool)) : []),
         ...(askUserEnabled ? [createAskUserToolDefinition()] : []),
@@ -686,7 +711,7 @@ function createPiWebEditToolDefinition(cwd, options) {
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             const preview = await computeEditPreview(params.path, params.edits, cwd);
             if (signal?.aborted !== true) {
-                onUpdate?.({ content: [{ type: "text", text: "Edit preview computed." }], details: { preview } });
+                onUpdate?.({ content: [{ type: "text", text: "Edit preview computed." }], details: { preview, presentation: { kind: "editPreviewComputed" } } });
             }
             return editTool.execute(toolCallId, params, signal, onUpdate, ctx);
         },
@@ -705,12 +730,19 @@ export class PiSessionService {
         this.activities = new SessionActivityCoordinator();
         /** Runtime-identity gate held while Pi may await abandoned-branch summarization. */
         this.treeNavigations = new WeakSet();
+        this.publishedSessionNames = new WeakMap();
+        /**
+         * Bare live leaf selected without an appended summary entry. Recording that
+         * leaf distinguishes the unpersisted move from a later runtime append that
+         * can anchor the selected branch on disk.
+         */
         this.unpersistedTreeBranchLeaves = new WeakMap();
         /** Counts async operations that may append an entry before they settle. */
         this.sessionEntryMutationCounts = new WeakMap();
         this.manualCompactionEnded = new WeakSet();
         this.extensionCommandExecution = new AsyncLocalStorage();
         this.runtimeMessageCounts = new WeakMap();
+        this.interventionStates = new WeakMap();
         this.snapshotMessageCounts = new WeakMap();
         this.pendingPromptEchoes = new WeakMap();
         this.publishedAssistantPartials = new WeakMap();
@@ -730,7 +762,6 @@ export class PiSessionService {
         this.subsessionStoppedParents = new WeakSet();
         this.subsessionDeliveringParents = new WeakSet();
         this.subsessionDeliveryScheduled = new WeakSet();
-        this.deferredGeneratedSessionNames = new WeakMap();
         this.compactionPromptQueues = new Map();
         this.compactionDrainTimers = new Map();
         this.authLossWarnings = new Set();
@@ -760,6 +791,7 @@ export class PiSessionService {
         this.mcpAuthOwners = new WeakMap();
         this.notificationGenerationBySession = new WeakMap();
         this.idleSessionFileResolutions = new WeakMap();
+        this.unreadEligibilityRevision = 0;
         /** The parked extension Promise resolvers behind the store's open dialogs. */
         this.dialogWaiters = new ExtensionDialogWaiters();
         this.pendingUnreadMutations = [];
@@ -768,6 +800,7 @@ export class PiSessionService {
         this.t = deps.translator ?? loadNodeTranslator("server");
         this.managementAllowPrivileged = deps.managementAllowPrivileged === true;
         this.archiveStore = deps.archiveStore ?? new SessionArchiveStore();
+        this.sessionPins = deps.sessionPins;
         this.pinStore = deps.pinStore ?? new SessionPinStore(join(deps.dataDir ?? piWebDataDir(), "session-pins.json"));
         this.agentDir = deps.agentDir ?? getAgentDir();
         this.dataDir = deps.dataDir ?? piWebDataDir();
@@ -789,6 +822,7 @@ export class PiSessionService {
             ? resolveDefaultModelRuntime
             : () => Promise.resolve(managementModelRuntime);
         this.spawnTargets = deps.spawnTargets;
+        this.messageTargets = deps.sessionMessagesEnabled === false ? undefined : deps.messageTargets ?? deps.spawnTargets;
         this.logger = deps.logger ?? noopLogger;
         this.normalToolAudit = deps.normalToolAudit;
         this.managementAudit = deps.managementAudit;
@@ -813,20 +847,24 @@ export class PiSessionService {
         this.sessionEvents = deps.sessionEvents ?? new PiSessionEventConnections();
         this.createRuntime = deps.createRuntime ?? createDefaultRuntimeFactory(this.sessionEvents, this.normalModelRuntimeForCwd, this.managementModelRuntime, (cwd, mode) => this.resolveSettingsScopeDirectory(cwd, mode), this.sessionManager, this.spawnTargets === undefined ? undefined : (input) => this.spawnSession(input), !subsessionsActive ? undefined : {
             spawn: (input) => this.spawnSubsession(input),
+            archive: (parentSessionId, sessionId, parentSessionFile, context) => this.archiveSubsession(parentSessionId, sessionId, parentSessionFile, context),
+            stop: (parentSessionId, sessionId, parentSessionFile, context) => this.stopSubsession(parentSessionId, sessionId, parentSessionFile, context),
+            resume: (parentSessionId, sessionId, prompt, parentSessionFile, context) => this.resumeSubsession(parentSessionId, sessionId, prompt, parentSessionFile, context),
             list: (parentSessionId, parentSessionFile, managementContext) => this.listSubsessions(parentSessionId, parentSessionFile, managementContext),
             join: (parentSessionId, parentSessionFile, toolCallId, managementContext) => this.joinSubsessions(parentSessionId, parentSessionFile, toolCallId, managementContext),
             prepare: (parentSessionId, parentSessionFile, managementContext) => this.prepareSubsessionDelivery(parentSessionId, parentSessionFile, managementContext),
             check: (parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext) => this.checkSubsession(parentSessionId, sessionId, parentSessionFile, toolCallId, managementContext),
             read: (parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext) => this.readSubsession(parentSessionId, sessionId, query, parentSessionFile, toolCallId, managementContext),
-        }, deps.askUserEnabled === true, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? [], deps.managementAllowPrivileged === true);
+        }, deps.askUserEnabled === true, deps.workbench, this.logger, this.managementAudit, this.managementProjectIdForCwd, deps.appendSystemPromptSections ?? [], deps.managementAllowPrivileged === true, this.messageTargets === undefined ? undefined : { send: (input, context) => this.sendSessionMessage(input, context) });
         this.createAgentRuntime = deps.createAgentRuntime ?? defaultCreateAgentRuntime;
         this.workspaceActivity = deps.workspaceActivity;
         this.heartbeat = setInterval(() => { this.publishHeartbeats(); }, deps.heartbeatIntervalMs ?? 2000);
         this.commandService = new SessionCommandService((sessionId, eventScope) => this.getActiveForCommand(sessionId, eventScope), (sessionId, text, eventScope) => this.submitCommandPrompt(sessionId, text, eventScope), events, {
+            onSessionNameChanged: (session) => { this.publishSessionName(session); },
             onCompactionStart: (session) => {
                 this.beginSessionEntryMutation(session, this.t("session.action.compact", "compact the session"));
                 this.manualCompactionEnded.delete(session);
-                this.publishActivity(session, this.t("activity.compacting", "Compacting context"), "active");
+                this.publishActivity(session, { kind: "compacting" }, "active");
                 this.publishStatus(session);
             },
             onCompactionEnd: (session, result, detail) => {
@@ -866,43 +904,25 @@ export class PiSessionService {
         return previewResponseFromPlan(await this.cleanupPlan(request));
     }
     async cleanup(request, context) {
-        const scope = eventScopeFromManagementContext(context);
         const plan = await this.cleanupPlan(request);
         if (plan.deleteRecords.length > 0 && this.archiveStore.deleteArchived === undefined && this.archiveStore.deleteArchivedMany === undefined)
             throw new Error(this.t("session.archiveDeleteUnsupported", "The archive store does not support deletion"));
-        const archiveInputs = [];
-        const readyArchiveInputs = [];
-        const deleteRecords = [];
-        const readyDeleteRecords = [];
-        const skippedBusySessionIds = new Set(plan.skippedBusySessionIds);
-        for (const input of plan.archiveInputs) {
-            if (this.activeSessionHasWork(input.sessionId)) {
-                skippedBusySessionIds.add(input.sessionId);
-                continue;
-            }
-            await this.closeActive(input.sessionId, { kind: "clear", reason: "archive" }, scope);
-            readyArchiveInputs.push(input);
-        }
-        await this.archiveStoreArchiveMany(readyArchiveInputs);
-        archiveInputs.push(...readyArchiveInputs);
-        await this.forgetUnreadSessions(readyArchiveInputs, scope);
-        for (const record of plan.deleteRecords) {
-            if (this.activeSessionHasWork(record.sessionId)) {
-                skippedBusySessionIds.add(record.sessionId);
-                continue;
-            }
-            await this.closeActive(record.sessionId, { kind: "clear", reason: "delete" }, scope);
-            readyDeleteRecords.push(record);
-        }
-        const deletedSessionIds = new Set(await this.archiveStoreDeleteArchivedMany(readyDeleteRecords.map((record) => record.sessionId)));
-        deleteRecords.push(...readyDeleteRecords.filter((record) => deletedSessionIds.has(record.sessionId)));
-        await this.forgetUnreadSessions(deleteRecords, scope);
+        const archived = await this.executeArchiveBatch(plan.archiveInputs, context);
+        if (archived.failures.length > 0)
+            throw new Error(archived.failures.map((failure) => `${failure.sessionId}: ${failure.error}`).join("; "));
+        const deleted = await this.executeDeleteArchivedBatch(plan.deleteRecords, context);
+        if (deleted.failures.length > 0)
+            throw new Error(deleted.failures.map((failure) => `${failure.sessionId}: ${failure.error}`).join("; "));
+        const archiveInputs = archived.successes;
+        const deleteRecords = deleted.successes;
+        const skippedBusySessionIds = new Set([...plan.skippedBusySessionIds, ...archived.skippedBusySessionIds, ...deleted.skippedBusySessionIds]);
         return summarizeSessionCleanupExecution({
             archiveInputs,
             deleteRecords,
             thresholds: plan.thresholds,
             generatedAt: plan.generatedAt,
             skippedBusySessionIds: [...skippedBusySessionIds],
+            ...(plan.skippedPinnedSessionIds === undefined ? {} : { skippedPinnedSessionIds: plan.skippedPinnedSessionIds }),
         });
     }
     async dispose() {
@@ -956,6 +976,18 @@ export class PiSessionService {
         });
         await this.publishUnreadMutations([]);
     }
+    /** Recover cold-session intervention flags without opening agent runtimes. */
+    async restoreInterventionState() {
+        const [sessions, archives] = await Promise.all([this.sessionManager.listAll(), this.archiveStore.list()]);
+        const archived = new Set(archives.map((record) => record.sessionId));
+        for (const session of sessions) {
+            if (!await normalSessionReadAllowed(session.cwd, this.projectPathForCwd, this.managementProjectRoot))
+                continue;
+            if (archived.has(session.id) || this.activeForLookup({ id: session.id, cwd: session.cwd }) !== undefined)
+                continue;
+            this.workspaceActivity?.applySessionIntervention(session.cwd, session.id, session.interventionRequired === true);
+        }
+    }
     async list(cwd, managementContext) {
         return (await this.listWorkspaceSessions(cwd, managementContext)).sessions;
     }
@@ -971,17 +1003,28 @@ export class PiSessionService {
         if (normalizedQuery === "")
             return { results: [], matchCount: 0, truncated: false };
         const maxMatches = 200;
-        const { listing, sessions } = await this.searchCandidates(cwd, normalizedQuery.toLocaleLowerCase(), managementContext);
-        const results = [];
+        const listing = await this.listWorkspaceSessions(cwd, managementContext);
+        const matchText = compileSessionContentQuery(normalizedQuery);
+        const candidates = [];
         let matchCount = 0;
-        for (const session of sessions) {
-            const remaining = maxMatches - results.reduce((count, result) => count + result.matches.length, 0);
-            const messages = this.searchableSessionHistory(session, listing, managementContext);
-            const view = searchSessionContent(messages, normalizedQuery, Math.max(1, remaining));
+        for (const session of listing.sessions) {
+            const messages = await this.searchableSessionHistory(session, listing, managementContext);
+            const view = searchSessionContent(messages, matchText, maxMatches);
             matchCount += view.matchCount;
-            if (remaining > 0 && view.matches.length > 0)
-                results.push({ session, matches: view.matches.slice(0, remaining) });
+            candidates.push(...view.matches.map((match) => ({ session, match })));
+            candidates.sort((left, right) => left.match.rank - right.match.rank);
+            candidates.length = Math.min(candidates.length, maxMatches);
+        }
+        const grouped = new Map();
+        for (const { session, match } of candidates) {
+            let result = grouped.get(session.id);
+            if (result === undefined) {
+                result = { session, matches: [] };
+                grouped.set(session.id, result);
+            }
+            result.matches.push({ messageIndex: match.messageIndex, role: match.role, excerpts: match.excerpts, occurrenceCount: match.occurrenceCount });
         }
+        const results = [...grouped.values()];
         return { results, matchCount, truncated: matchCount > maxMatches };
     }
     async listPinned(cwd, managementContext) {
@@ -1025,11 +1068,17 @@ export class PiSessionService {
             const listed = unarchivedById.get(session.sessionId);
             const tracked = this.subsessionLinkForActiveChild(session) !== undefined;
             if (listed !== undefined) {
-                if (tracked && session.sessionFile !== undefined && sessionPathsEqual(listed.path, session.sessionFile))
-                    listed.agentSubsession = true;
+                // Match the file too: a clone with the same id must not inherit a
+                // live runtime's classification. Disk rows otherwise use the scanner.
+                if (session.sessionFile !== undefined && sessionPathsEqual(listed.path, session.sessionFile)) {
+                    if (tracked)
+                        listed.agentSubsession = true;
+                    listed.interventionRequired = this.statusFromSession(session).interventionRequired === true;
+                }
                 continue;
             }
             const info = clientSessionFromActiveSession(session);
+            info.interventionRequired = this.statusFromSession(session).interventionRequired === true;
             if (tracked)
                 info.agentSubsession = true;
             unarchivedById.set(session.sessionId, info);
@@ -1040,6 +1089,10 @@ export class PiSessionService {
         if (managementContext === undefined) {
             await this.publishUnreadMutations(this.unreadForScope(eventScopeFromManagementContext(managementContext)).reconcileCwd(canonicalizeStoredCwd(cwd), reconcilableSessionIds));
         }
+        for (const session of unarchivedSessions) {
+            if (this.activeForLookup({ id: session.id, cwd }, managementContext) === undefined)
+                this.workspaceActivity?.applySessionIntervention(cwd, session.id, session.interventionRequired === true, eventScopeFromManagementContext(managementContext));
+        }
         const archivedSessions = archivedForCwd
             .map((record) => clientSessionFromArchivedRecord(record, sessionsById.get(record.sessionId)))
             .filter(isDefined)
@@ -1074,18 +1127,41 @@ export class PiSessionService {
                 continue;
             const row = rows.get(session.sessionId);
             // A disk clone with the same id must not inherit another file's runtime.
-            if (row !== undefined && (session.sessionFile === undefined || !sessionPathsEqual(row.path, session.sessionFile)))
+            if (row !== undefined && (row.path === undefined || session.sessionFile === undefined || !sessionPathsEqual(row.path, session.sessionFile)))
                 continue;
             runtimes.set(session.sessionId, session);
-            rows.set(session.sessionId, clientSessionFromActiveSession(session));
+            const headerCreated = session.sessionManager.getHeader?.()?.timestamp;
+            const metadata = readSessionUiMetadata(session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch());
+            const created = row?.created ?? (headerCreated !== undefined && Number.isFinite(Date.parse(headerCreated)) ? new Date(headerCreated).toISOString() : undefined);
+            // Scanner dates match native cleanup eligibility. A hosted-only runtime's
+            // header records creation, not its most recent activity.
+            rows.set(session.sessionId, {
+                id: session.sessionId,
+                cwd: session.sessionManager.getCwd(),
+                ...(session.sessionName === undefined ? {} : { name: session.sessionName }),
+                ...(metadata === undefined ? {} : { metadata }),
+                ...(created === undefined ? {} : { created }),
+                ...(row?.modified === undefined ? {} : { modified: row.modified }),
+            });
         }
         const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
         for (const record of archived) {
-            const row = clientSessionFromArchivedRecord(record, entriesById.get(record.sessionId));
-            if (row !== undefined)
-                rows.set(row.id, row);
+            const entry = entriesById.get(record.sessionId);
+            const created = record.created ?? entry?.created.toISOString();
+            const modified = record.modified ?? entry?.modified.toISOString();
+            // Legacy records may lack transcript/path fields required by the client
+            // list helper; their archive identity and known dates are still usable.
+            const row = clientSessionFromArchivedRecord(record, entry) ?? {
+                id: record.sessionId,
+                cwd: record.cwd,
+                ...(created === undefined ? {} : { created }),
+                ...(modified === undefined ? {} : { modified }),
+                archived: true,
+                archivedAt: record.archivedAt,
+            };
+            rows.set(row.id, row);
         }
-        return [...rows.values()].sort((a, b) => Date.parse(b.modified) - Date.parse(a.modified)).map((row) => {
+        return [...rows.values()].sort((a, b) => (b.modified === undefined ? 0 : Date.parse(b.modified)) - (a.modified === undefined ? 0 : Date.parse(a.modified))).map((row) => {
             const runtime = runtimes.get(row.id);
             return Object.freeze({
                 id: row.id,
@@ -1093,6 +1169,9 @@ export class PiSessionService {
                 ...(row.name === undefined ? {} : { name: row.name }),
                 ...(row.metadata === undefined ? {} : { metadata: structuredClone(row.metadata) }),
                 archived: row.archived === true,
+                created: row.created ?? null,
+                modified: row.modified ?? null,
+                archivedAt: row.archived === true ? row.archivedAt ?? null : null,
                 runtime: runtime === undefined ? "not-hosted" : this.hasActiveWork(runtime) ? "busy" : "idle",
             });
         });
@@ -1108,24 +1187,56 @@ export class PiSessionService {
         return Object.freeze({ id: created.id });
     }
     /** Atomically start and prompt one visible normal-mode, non-delegating session. */
-    async startOneShotRun(cwd, text, signal) {
+    async startOneShotRun(cwd, text, signal, options = {}) {
         const promptText = requirePromptText(text, this.t);
-        return this.startManagedSession(cwd, signal, promptText);
+        return this.startManagedSession(cwd, signal, promptText, options);
     }
-    async startManagedSession(cwd, signal, promptText) {
+    async startManagedSession(cwd, signal, promptText, options = {}) {
         signal.throwIfAborted();
-        await this.normalModelRuntimeForCwd(cwd);
-        const active = await this.create(this.sessionManager.create(cwd), cwd, { startupIntent: "create", creationProvenance: "host-one-shot", startupSignal: signal });
+        const modelRuntime = await this.normalModelRuntimeForCwd(cwd);
+        let initialModel;
+        if (options.model !== undefined) {
+            await modelRuntime.refresh({ allowNetwork: false });
+            signal.throwIfAborted();
+            // Catalog membership alone does not mean the provider still has credentials
+            // or is configured. Host overrides must be available after the refresh.
+            initialModel = modelRuntime.getAvailableSnapshot().find((model) => modelScopeId(model) === options.model);
+            if (initialModel === undefined) {
+                throw Object.assign(new Error(`Model unavailable: ${options.model}`), { code: "PI_SESSION_MODEL_UNAVAILABLE" });
+            }
+        }
+        const active = await this.create(this.sessionManager.create(cwd), cwd, {
+            startupIntent: "create", creationProvenance: "host-one-shot", startupSignal: signal,
+            ...(initialModel === undefined ? {} : { initialModel }),
+        });
         const { session } = active.runtime;
         try {
             signal.throwIfAborted();
-            if (promptText !== undefined)
-                this.maybeGenerateSessionName(session, promptText);
+            // Startup extensions may change the model. Never submit with a fallback
+            // when the caller requested an exact model.
+            if (options.model !== undefined && (session.model === undefined || modelScopeId(session.model) !== options.model)) {
+                throw Object.assign(new Error(`Requested model is not active: ${options.model}`), { code: "PI_SESSION_MODEL_UNAVAILABLE" });
+            }
+            if (options.thinkingLevel !== undefined) {
+                // Do not pass requested thinking into startup: the SDK can silently
+                // clamp it before we have the actual model's supported levels.
+                if (!session.getAvailableThinkingLevels().includes(options.thinkingLevel)) {
+                    throw Object.assign(new Error(`Thinking level unavailable: ${options.thinkingLevel}`), { code: "PI_SESSION_THINKING_UNAVAILABLE" });
+                }
+                session.setThinkingLevel(options.thinkingLevel);
+                if (session.thinkingLevel !== options.thinkingLevel) {
+                    throw Object.assign(new Error(`Thinking level was not applied: ${options.thinkingLevel}`), { code: "PI_SESSION_THINKING_UNAVAILABLE" });
+                }
+            }
+            const settings = {
+                ...(session.model === undefined ? {} : { model: modelScopeId(session.model) }),
+                thinkingLevel: session.thinkingLevel,
+            };
             const created = this.announceCreatedSession(active, cwd);
             // Publication transfers lifetime ownership to normal hosting. Plugin
             // cancellation after this point must not abort this or later user work.
             const completion = promptText === undefined ? Promise.resolve() : this.submitInitialRunPrompt(session, promptText);
-            return Object.freeze({ id: created.id, completion });
+            return Object.freeze({ id: created.id, completion, ...settings });
         }
         catch (error) {
             try {
@@ -1518,6 +1629,96 @@ export class PiSessionService {
             ...(outcome.answer === undefined ? {} : { answer: outcome.answer }),
         }, this.eventScopeForSession(session));
     }
+    /** Interrupt a direct child's current run without closing its conversation. */
+    async stopSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
+        const child = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
+        const cwd = child.sessionManager.getCwd();
+        await this.abort({ id: sessionId, cwd }, managementContext);
+        return { sessionId, cwd, status: this.subsessionStatus(child) };
+    }
+    /** Start another run in a direct child's conversation, without prompt expansion. */
+    async resumeSubsession(parentSessionId, sessionId, prompt, parentSessionFile, managementContext) {
+        const child = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
+        const cwd = child.sessionManager.getCwd();
+        await this.assertWritable({ id: sessionId, cwd }, managementContext);
+        this.assertTreeNavigationInactive(child, "resume a subsession");
+        if (this.hasActiveWork(child))
+            throw new Error("Subsession is already working");
+        const text = requirePromptText(prompt ?? "Continue your previous task from the current conversation and workspace state. Check any interrupted work before repeating it.", this.t);
+        void this.beginPromptSubmission(child, text, undefined, [], true, { expandPromptTemplates: false }).catch(() => undefined);
+        return { sessionId, cwd, status: "working" };
+    }
+    /** Archive a direct child using the same idle-only operation as the browser. */
+    async archiveSubsession(parentSessionId, sessionId, parentSessionFile, managementContext) {
+        const child = await this.openSubsession(parentSessionId, sessionId, parentSessionFile, managementContext);
+        await this.archive({ id: sessionId, cwd: child.sessionManager.getCwd() }, managementContext);
+    }
+    /** Send content, not control authority, to a named session in the same project. */
+    async sendSessionMessage(input, managementContext) {
+        if (this.messageTargets === undefined)
+            throw new Error("Session messaging is unavailable");
+        const message = requirePromptText(input.message, this.t);
+        if (managementContext === undefined)
+            await this.assertNormalSessionReadAccess(input.sendingCwd);
+        else
+            await this.getActive({ id: input.sendingSessionId, cwd: input.sendingCwd }, managementContext);
+        const active = this.activeForLookup(input.sessionId, managementContext);
+        const target = active === undefined
+            ? (await this.sessionManager.listAll()).find((entry) => entry.id === input.sessionId)
+            : { id: input.sessionId, cwd: active.runtime.cwd };
+        if (target === undefined)
+            throw new Error("Session not found");
+        if (active === undefined && this.activeSessionsForId(input.sessionId).some((entry) => cwdPathsEqual(entry.runtime.cwd, target.cwd)))
+            throw new Error("Session not found");
+        const decision = await this.messageTargets.resolveSpawnTarget(input.sendingCwd, target.cwd, eventScopeFromManagementContext(managementContext));
+        if (!decision.allowed)
+            throw new Error("Session messaging is limited to sessions in the same registered project");
+        if (managementContext === undefined)
+            await this.assertNormalSessionReadAccess(decision.cwd);
+        else {
+            if (this.managementProjectRoot === undefined)
+                throw new Error("Managed session messaging requires a project root");
+            await assertManagedCwd(this.managementProjectRoot, managementContext, decision.cwd, { create: false });
+        }
+        const ref = { id: input.sessionId, cwd: decision.cwd };
+        await this.assertWritable(ref, managementContext);
+        const session = await this.getOrOpen(ref, managementContext);
+        this.assertTreeNavigationInactive(session, "receive a session message");
+        const delivery = this.hasActiveWork(session) ? "queued" : "started";
+        let agentStarted = false;
+        const unsubscribe = session.subscribe((event) => {
+            if (getString(event, "type") === "agent_start")
+                agentStarted = true;
+        });
+        // A custom-message turn may run for minutes. Never wait for its answer in
+        // the sender: reciprocal messages must not deadlock their tool calls.
+        void this.runSessionEntryMutation(session, "receive a session message", async () => {
+            if (session.isCompacting || session.isBashRunning)
+                await session.waitForIdle();
+            if (!this.isCurrentActiveSession(session))
+                throw new Error("Session was closed before message delivery");
+            await session.sendCustomMessage({
+                customType: "session.message",
+                content: `Message from session ${input.sendingSessionId}:\n\n${message}`,
+                display: true,
+                details: { sendingSessionId: input.sendingSessionId },
+            }, { triggerTurn: true, deliverAs: "steer" });
+        }).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.logger.info({ sessionId: input.sessionId, sendingSessionId: input.sendingSessionId, error: detail }, "session message delivery failed");
+            if (!this.isCurrentActiveSession(session))
+                return;
+            this.publishActivity(session, { kind: "error" }, "error", detail);
+            const scope = this.eventScopeForSession(session);
+            this.events.publish(session.sessionId, { type: "session.error", message: detail }, scope);
+            if (!agentStarted && this.subsessionLinkForActiveChild(session) !== undefined)
+                this.subsessionNotifyArmed.set(activeSessionKey(session.sessionId, scope), true);
+            this.updateSubsessionTracking(session);
+            this.publishStatus(session);
+        }).finally(unsubscribe);
+        this.logger.info({ sendingSessionId: input.sendingSessionId, sessionId: input.sessionId, delivery }, "session message accepted");
+        return { sessionId: input.sessionId, delivery };
+    }
     /** Summaries of the tracked subsessions spawned by `parentSessionId`. */
     async listSubsessions(parentSessionId, parentSessionFile, managementContext) {
         const parentFile = nonEmptyString(parentSessionFile);
@@ -2015,13 +2216,17 @@ export class PiSessionService {
         }));
         return { listing, sessions: matches.filter(isDefined) };
     }
-    searchableSessionHistory(session, listing, managementContext) {
+    async searchableSessionHistory(session, listing, managementContext) {
         const eventScope = eventScopeFromManagementContext(managementContext);
         const active = this.activeForSessionIdAndScope(session.id, eventScope);
         if (active !== undefined && cwdPathsEqual(active.runtime.cwd, session.cwd))
             return historyMessages(active.runtime.session);
         const path = listing.archivedById.get(session.id)?.archivePath ?? listing.entriesById.get(session.id)?.path;
-        return path === undefined ? [] : historyMessagesFromManager(this.sessionManager.open(path));
+        if (path === undefined)
+            return [];
+        if (this.sessionManager.readBranch !== undefined)
+            return historyMessagesFromEntries(await this.sessionManager.readBranch(path) ?? []);
+        return historyMessagesFromManager(this.sessionManager.open(path));
     }
     async streamSnapshot(ref, managementContext) {
         const session = await this.getOrOpen(ref, managementContext);
@@ -2159,7 +2364,7 @@ export class PiSessionService {
         if (model === undefined)
             throw new Error(this.t("model.notFound", "Model not found: {value0}/{value1}", { value0: provider, value1: modelId }));
         await this.runSessionEntryMutation(session, this.t("server.main.130226a572df", "change models"), () => session.setModel(model));
-        this.publishActivity(session, this.t("activity.model", "Model: {value0}", { value0: model.id }), "idle", model.provider);
+        this.publishActivity(session, { kind: "model", value: model.id }, "idle", model.provider);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -2173,7 +2378,7 @@ export class PiSessionService {
         });
         if (result === undefined)
             throw new Error(session.scopedModels.length > 0 ? this.t("model.oneScoped", "Only one scoped model is available") : this.t("model.oneAvailable", "Only one model is available"));
-        this.publishActivity(session, this.t("activity.model", "Model: {value0}", { value0: result.model.id }), "idle", result.model.provider);
+        this.publishActivity(session, { kind: "model", value: result.model.id }, "idle", result.model.provider);
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -2195,7 +2400,7 @@ export class PiSessionService {
             session.setThinkingLevel(match);
             return Promise.resolve();
         });
-        this.publishActivity(session, this.t("activity.thinking", "Thinking level: {value0}", { value0: session.thinkingLevel }), "idle");
+        this.publishActivity(session, { kind: "thinking", value: session.thinkingLevel }, "idle");
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -2205,7 +2410,7 @@ export class PiSessionService {
         const level = await this.runSessionEntryMutation(session, this.t("session.action.changeThinking", "change the thinking level"), () => Promise.resolve(session.cycleThinkingLevel()));
         if (level === undefined)
             throw new Error(this.t("model.thinkingUnsupported", "The current model does not support thinking"));
-        this.publishActivity(session, this.t("ui.promptEditor.thinkingLevel", "Thinking level: {thinkingLevel}", { thinkingLevel: level }), "idle");
+        this.publishActivity(session, { kind: "thinking", value: level }, "idle");
         this.publishStatus(session);
         return this.statusFromSession(session);
     }
@@ -2241,11 +2446,10 @@ export class PiSessionService {
         await this.assertWritable(ref, options?.managementContext);
         const session = await this.getOrOpen(ref, options?.managementContext);
         this.assertTreeNavigationInactive(session, this.t("server.main.94306b2fc35c", "send a prompt"));
-        this.maybeGenerateSessionName(session, promptText);
         const isQueued = session.isStreaming || session.isCompacting;
         const behavior = isQueued ? requestedBehavior ?? "followUp" : undefined;
         if (isQueued && images.length === 0 && this.hasQueuedMessageText(session, promptText)) {
-            this.publishActivity(session, this.t("activity.duplicateIgnored", "Duplicate queued message ignored"), "active");
+            this.publishActivity(session, { kind: "duplicateQueuedMessage" }, "active");
             this.publishStatus(session);
             return;
         }
@@ -2267,7 +2471,7 @@ export class PiSessionService {
     beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true, options = {}) {
         if (options.auditUserPrompt !== false)
             this.auditUserPrompt(session, text);
-        this.publishActivity(session, behavior === "steer" ? this.t("activity.steerQueued", "Steering message queued") : behavior === "followUp" ? this.t("activity.messageQueued", "Message queued") : this.t("activity.messageReceived", "Message received"), "active");
+        this.publishActivity(session, behavior === "steer" ? { kind: "steeringQueued" } : behavior === "followUp" ? { kind: "messageQueued" } : { kind: "promptAccepted" }, "active");
         const eventScope = this.eventScopeForSession(session);
         const echoes = this.pendingPromptEchoes.get(session) ?? [];
         const userCount = historyMessagesFromEntries(session.sessionManager.getBranch()).filter((message) => isRecord(message) && message["role"] === "user").length;
@@ -2308,7 +2512,7 @@ export class PiSessionService {
         void promptPromise.catch((error) => {
             this.subsessionStoppedParents.add(session);
             const message = error instanceof Error ? error.message : String(error);
-            this.publishActivity(session, this.t("activity.error", "An error occurred"), "error", message);
+            this.publishActivity(session, { kind: "error" }, "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
             if (this.isCurrentActiveSession(session)) {
                 const link = this.subsessionLinkForActiveChild(session);
@@ -2372,7 +2576,7 @@ export class PiSessionService {
         const queue = this.compactionPromptQueues.get(sessionKey) ?? [];
         queue.push({ kind, text, ...(images.length > 0 ? { images } : {}), ...(echoUserMessage ? {} : { echoUserMessage: false }) });
         this.compactionPromptQueues.set(sessionKey, queue);
-        this.publishActivity(session, this.t("activity.compactionQueued", "Message queued during compaction"), "active");
+        this.publishActivity(session, { kind: "queuedDuringCompaction" }, "active");
         this.publishStatus(session);
     }
     async saveAttachments(ref, attachments, folder, managementContext) {
@@ -2386,8 +2590,8 @@ export class PiSessionService {
         return saveAttachmentsToWorkspace(cwd, parsed, effectiveFolder === undefined ? {} : { folder: effectiveFolder });
     }
     async workspaceAttachmentsConfig(cwd) {
-        const globalConfig = this.config === undefined ? {} : (await this.config.read()).effectiveConfig;
-        return loadEffectiveProjectAttachmentsConfig(cwd, globalConfig);
+        const response = this.config === undefined ? undefined : await this.config.read();
+        return loadEffectiveProjectAttachmentsConfig(cwd, response?.effectiveConfig ?? {}, response?.enforcedSettings);
     }
     async shell(ref, text, managementContext) {
         await this.assertWritable(ref, managementContext);
@@ -2401,11 +2605,11 @@ export class PiSessionService {
         if (session.isBashRunning)
             throw new Error(this.t("shell.alreadyRunning", "A bash command is already running"));
         const eventScope = active.eventScope;
-        this.publishActivity(session, this.t("activity.commandRunning", "Running command"), "active", command);
+        this.publishActivity(session, { kind: "runningBash" }, "active", command);
         this.events.publish(session.sessionId, { type: "shell.start", command, excludeFromContext: isExcluded }, eventScope);
         void this.runSessionEntryMutation(session, this.t("session.action.shell", "run a shell command"), () => session.executeBash(command, (chunk) => {
             this.events.publish(session.sessionId, { type: "shell.chunk", chunk }, eventScope);
-            this.publishActivity(session, this.t("activity.commandRunning", "Running command"), "active", command);
+            this.publishActivity(session, { kind: "runningBash" }, "active", command);
             this.publishStatus(session);
         }, { excludeFromContext: isExcluded })).then((result) => {
             this.events.publish(session.sessionId, {
@@ -2416,13 +2620,13 @@ export class PiSessionService {
                 truncated: result.truncated,
                 ...(result.fullOutputPath === undefined ? {} : { fullOutputPath: result.fullOutputPath }),
             }, eventScope);
-            this.publishActivity(session, this.t("activity.commandCompleted", "Command completed"), result.exitCode === 0 ? "idle" : "error", command);
+            this.publishActivity(session, { kind: "bashComplete" }, result.exitCode === 0 ? "idle" : "error", command);
             this.publishStatus(session);
         }).catch((error) => {
             const message = userFacingErrorMessage(error, this.t);
             this.events.publish(session.sessionId, { type: "shell.end", output: message, isError: true }, eventScope);
             this.events.publish(session.sessionId, { type: "session.error", message }, eventScope);
-            this.publishActivity(session, this.t("activity.commandFailed", "Command failed"), "error", message);
+            this.publishActivity(session, { kind: "bashFailed" }, "error", message);
             this.publishStatus(session);
         });
     }
@@ -2469,7 +2673,7 @@ export class PiSessionService {
             if (retainCustomMessage && options.summarize === true)
                 throw new Error(this.t("session.checkpointSummary", "Retaining a custom-message checkpoint requires navigation without a branch summary"));
             const activeEditableTargetParentId = retainCustomMessage ? undefined : activeEditableTreeTargetParentId(session.sessionManager, targetId, oldLeafId);
-            this.publishActivity(session, options.summarize === true ? this.t("activity.summarizing", "Summarizing branch") : this.t("activity.navigating", "Navigating session tree"), "active");
+            this.publishActivity(session, options.summarize === true ? { kind: "summarizingBranch" } : { kind: "navigatingTree" }, "active");
             this.publishStatus(session);
             let result = retainCustomMessage
                 ? await navigateTreeRetainingCustomMessage(session.sessionManager, targetId, checkpointTail["parentId"], () => navigateTree(targetId, options))
@@ -2490,7 +2694,7 @@ export class PiSessionService {
             }
             if (result.cancelled) {
                 if (this.isCurrentActiveSession(session)) {
-                    this.publishActivity(session, result.aborted === true ? this.t("activity.summaryAborted", "Branch summary aborted") : this.t("activity.navigationCancelled", "Session tree navigation cancelled"), "idle");
+                    this.publishActivity(session, result.aborted === true ? { kind: "branchSummaryAborted" } : { kind: "treeNavigationCancelled" }, "idle");
                 }
                 return { cancelled: true, ...(result.aborted === undefined ? {} : { aborted: result.aborted }) };
             }
@@ -2505,13 +2709,13 @@ export class PiSessionService {
             this.setSuggestedInput(session, result.editorText);
             this.events.publish(session.sessionId, { type: "session.tree.changed" }, this.eventScopeForSession(session));
             if (this.isCurrentActiveSession(session))
-                this.publishActivity(session, this.t("activity.navigated", "Session tree changed"), "idle");
+                this.publishActivity(session, { kind: "treeNavigated" }, "idle");
             return { cancelled: false, ...(result.editorText === undefined ? {} : { editorText: result.editorText }) };
         }
         catch (error) {
             const message = userFacingErrorMessage(error, this.t);
             if (this.isCurrentActiveSession(session)) {
-                this.publishActivity(session, this.t("server.main.8cae209986b4", "tree navigation failed"), "error", message);
+                this.publishActivity(session, { kind: "treeNavigationFailed" }, "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
             }
             throw error;
@@ -2524,7 +2728,6 @@ export class PiSessionService {
                 this.publishStatus(session);
             }
             else {
-                this.deferredGeneratedSessionNames.delete(session);
                 this.subsessionInbox(session.sessionId, session.sessionFile, this.eventScopeForSession(session)).releaseClaims();
             }
         }
@@ -2551,7 +2754,7 @@ export class PiSessionService {
         const sourceSessionId = session.sessionId;
         const sourceEventScope = this.eventScopeForSession(session);
         const sourceCwd = session.sessionManager.getCwd();
-        this.publishActivity(session, this.t("server.main.4de911d3b72a", "forking session from entry"), "active");
+        this.publishActivity(session, { kind: "forking" }, "active");
         this.publishStatus(session);
         try {
             const entryId = request.retainCheckpoint === true ? messageHistoryTargetId(session.sessionManager.getBranch(), request.entryId) : request.entryId;
@@ -2564,7 +2767,7 @@ export class PiSessionService {
                 throw new Error(this.t("server.main.0246b6af6843", "Session fork is unavailable"));
             if (result.session === undefined) {
                 if (this.isCurrentActiveSession(session)) {
-                    this.publishActivity(session, this.t("server.main.1cceead5f414", "fork cancelled"), "idle");
+                    this.publishActivity(session, { kind: "forkCancelled" }, "idle");
                     this.publishStatus(session);
                 }
                 return { cancelled: true };
@@ -2574,7 +2777,7 @@ export class PiSessionService {
                 this.setSuggestedInput(forked, result.promptDraft);
             this.events.publish(sourceSessionId, { type: "session.tree.changed" }, sourceEventScope);
             if (forked !== undefined && this.isCurrentActiveSession(forked)) {
-                this.publishActivity(forked, this.t("command.forked", "Session forked"), "idle");
+                this.publishActivity(forked, { kind: "forked" }, "idle");
                 this.publishStatus(forked);
             }
             if (result.session.id !== sourceSessionId)
@@ -2588,7 +2791,7 @@ export class PiSessionService {
         catch (error) {
             const message = userFacingErrorMessage(error, this.t);
             if (this.isCurrentActiveSession(session)) {
-                this.publishActivity(session, this.t("server.main.08e8f3ea9eaa", "fork failed"), "error", message);
+                this.publishActivity(session, { kind: "forkFailed" }, "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, sourceEventScope);
                 this.publishStatus(session);
             }
@@ -2599,7 +2802,7 @@ export class PiSessionService {
         const sessionKey = activeSessionKey(sessionId, eventScope);
         if (this.activities.get(sessionKey)?.phase === "active") {
             const at = new Date().toISOString();
-            const stored = { phase: "idle", label: this.t("activity.idle", "Idle"), at };
+            const stored = { phase: "idle", label: "idle", at, runtimePresentation: { kind: "idle" } };
             this.activities.set(sessionKey, stored);
             const activity = { sessionId, ...stored };
             this.events.publish(sessionId, { type: "activity.update", activity }, eventScope);
@@ -2615,6 +2818,7 @@ export class PiSessionService {
             const archiveInput = await this.archiveInputForSession(session);
             await this.closeActiveSession(active);
             await this.archiveStore.archive(archiveInput);
+            this.workspaceActivity?.removeSession(archiveInput.sessionId, archiveInput.cwd, active.eventScope);
             await this.forgetUnreadSessions([archiveInput], active.eventScope);
         });
     }
@@ -2658,43 +2862,10 @@ export class PiSessionService {
                 failures.push({ sessionId: resolvedSessionId, error: errorMessage(error, this.t) });
             }
         }
-        const readyPlanItems = [];
-        for (const item of planItems) {
-            const active = item.active ?? this.activeForLookup(bulkRefToLookup({ id: item.input.sessionId, cwd: item.input.cwd }), managementContext);
-            if (active !== undefined && this.hasActiveWork(active.runtime.session)) {
-                failures.push({ sessionId: item.input.sessionId, error: this.t("session.stopBeforeArchive", "Stop current session activity before archiving") });
-                continue;
-            }
-            readyPlanItems.push(active === undefined ? item : { ...item, active });
-        }
-        const readyInputs = [];
-        const archivedSessionIds = [...alreadyArchivedSessionIds];
-        await this.runTreeExclusiveOperation(readyPlanItems.map(({ input, active }) => ({
-            sessionId: input.sessionId,
-            ...(active === undefined ? {} : { session: active.runtime.session, runtime: active.runtime }),
-        })), this.t("session.stopBeforeArchive", "Stop current session activity before archiving"), async () => {
-            for (const item of readyPlanItems) {
-                try {
-                    if (item.active !== undefined)
-                        await this.closeActiveSession(item.active);
-                    else
-                        await this.closeActiveInScope(item.input.sessionId, eventScopeFromManagementContext(managementContext));
-                    readyInputs.push(item.input);
-                }
-                catch (error) {
-                    failures.push({ sessionId: item.input.sessionId, error: errorMessage(error, this.t) });
-                }
-            }
-            try {
-                const archived = await this.archiveStoreArchiveMany(readyInputs);
-                archivedSessionIds.push(...archived.map((record) => record.sessionId));
-                unreadArchivedIdentities.push(...archived);
-            }
-            catch (error) {
-                for (const input of readyInputs)
-                    failures.push({ sessionId: input.sessionId, error: errorMessage(error, this.t) });
-            }
-        });
+        const execution = await this.executeArchiveBatch(planItems.map((item) => item.input), managementContext);
+        failures.push(...execution.failures);
+        failures.push(...execution.skippedBusySessionIds.map((sessionId) => ({ sessionId, error: this.t("session.stopBeforeArchive", "Stop current session activity before archiving") })));
+        const archivedSessionIds = [...alreadyArchivedSessionIds, ...execution.successes.map((input) => input.sessionId)];
         await this.forgetUnreadSessions(unreadArchivedIdentities, eventScopeFromManagementContext(managementContext));
         return {
             archived: true,
@@ -2722,7 +2893,9 @@ export class PiSessionService {
             }
             for (const input of archiveInputs)
                 await this.closeActiveInScope(input.sessionId, eventScopeFromManagementContext(managementContext));
-            await this.archiveStoreArchiveMany(archiveInputs);
+            const archived = await this.archiveStoreArchiveMany(archiveInputs);
+            for (const record of archived)
+                this.workspaceActivity?.removeSession(record.sessionId, record.cwd, eventScopeFromManagementContext(managementContext));
         });
         await this.forgetUnreadSessions(plan.targets.map((target) => ({ sessionId: target.id, cwd: target.cwd })), eventScopeFromManagementContext(managementContext));
         return {
@@ -2735,10 +2908,15 @@ export class PiSessionService {
     async restore(ref, managementContext) {
         const archived = await this.getArchived(ref);
         if (archived === undefined)
-            throw new Error(this.t("session.notFound", "Session not found"));
-        await this.closeActiveInScope(archived.sessionId, eventScopeFromManagementContext(managementContext));
-        await this.archiveStore.restore(archived.sessionId);
-        await this.forgetUnreadSessions([archived], eventScopeFromManagementContext(managementContext));
+            throw new Error("Session not found");
+        const active = this.activeForLookup({ id: archived.sessionId, cwd: archived.cwd }, managementContext);
+        await this.runTreeExclusiveOperation([{ sessionId: archived.sessionId, ...(active === undefined ? {} : { session: active.runtime.session, runtime: active.runtime }) }], "Stop current session activity before restoring archived session", async () => {
+            await this.closeActiveInScope(archived.sessionId, eventScopeFromManagementContext(managementContext));
+            await this.archiveStore.restore(archived.sessionId);
+            const restored = (await this.sessionManager.list(archived.cwd)).find((entry) => entry.id === archived.sessionId);
+            this.workspaceActivity?.applySessionIntervention(archived.cwd, archived.sessionId, restored?.interventionRequired === true, eventScopeFromManagementContext(managementContext));
+            await this.forgetUnreadSessions([archived], eventScopeFromManagementContext(managementContext));
+        });
     }
     async deleteArchived(ref, managementContext) {
         const record = await this.getArchived(ref);
@@ -2770,27 +2948,10 @@ export class PiSessionService {
             }
             planItems.push({ record });
         }
-        const readyRecords = [];
-        for (const item of planItems) {
-            try {
-                await this.closeActiveInScope(item.record.sessionId, eventScopeFromManagementContext(managementContext));
-                readyRecords.push(item.record);
-            }
-            catch (error) {
-                failures.push({ sessionId: item.record.sessionId, error: errorMessage(error, this.t) });
-            }
-        }
-        const deleteIds = readyRecords.map((record) => record.sessionId);
-        let deletedSessionIds = [];
-        try {
-            deletedSessionIds = await this.archiveStoreDeleteArchivedMany(deleteIds);
-        }
-        catch (error) {
-            for (const sessionId of deleteIds)
-                failures.push({ sessionId, error: errorMessage(error, this.t) });
-        }
-        const deletedIdSet = new Set(deletedSessionIds);
-        await this.forgetUnreadSessions(readyRecords.filter((record) => deletedIdSet.has(record.sessionId)), eventScopeFromManagementContext(managementContext));
+        const execution = await this.executeDeleteArchivedBatch(planItems.map((item) => item.record), managementContext);
+        failures.push(...execution.failures);
+        failures.push(...execution.skippedBusySessionIds.map((sessionId) => ({ sessionId, error: this.t("session.stopBeforeDeleteArchive", "Stop current session activity before deleting archived session") })));
+        const deletedSessionIds = execution.successes.map((record) => record.sessionId);
         return {
             deleted: true,
             deletedSessionIds,
@@ -2860,11 +3021,11 @@ export class PiSessionService {
         this.abortRunScopedExtensionDialogs(active.runtime.session);
         try {
             await this.abortSessionOperations(active.runtime.session);
-            this.publishActivity(active.runtime.session, this.t("activity.stopped", "Stopped"), "idle");
+            this.publishActivity(active.runtime.session, { kind: "stopped" }, "idle");
         }
         catch (error) {
             const message = userFacingErrorMessage(error, this.t);
-            this.publishActivity(active.runtime.session, this.t("activity.stopFailed", "Stop failed"), "error", message);
+            this.publishActivity(active.runtime.session, { kind: "stopFailed" }, "error", message);
             throw error;
         }
         finally {
@@ -3025,6 +3186,58 @@ export class PiSessionService {
         const entries = await Promise.all(uniqueCwds.map(async (cwd) => [cwd, await this.sessionManager.list(cwd)]));
         return new Map(entries);
     }
+    executeArchiveBatch(inputs, context) {
+        return this.executeSessionLifecycleBatch(inputs, "archive", async (ready) => (await this.archiveStoreArchiveMany(ready)).map((record) => record.sessionId), context);
+    }
+    executeDeleteArchivedBatch(records, context) {
+        return this.executeSessionLifecycleBatch(records, "delete", (ready) => this.archiveStoreDeleteArchivedMany(ready.map((record) => record.sessionId)), context);
+    }
+    async executeSessionLifecycleBatch(items, reason, persist, context) {
+        const scope = eventScopeFromManagementContext(context);
+        const result = { successes: [], failures: [], skippedBusySessionIds: [] };
+        const targets = [];
+        const idleItems = [];
+        // Check and reserve synchronously before any teardown can yield. Identity
+        // reservations also protect unloaded sessions for the full persistence span.
+        for (const item of items) {
+            const active = this.activeForLookup({ id: item.sessionId, cwd: item.cwd }, context);
+            if (this.isTreeExclusiveSessionIdentityActive(item.sessionId)
+                || (active !== undefined && this.hasActiveWork(active.runtime.session))) {
+                result.skippedBusySessionIds.push(item.sessionId);
+                continue;
+            }
+            idleItems.push(item);
+            targets.push({ sessionId: item.sessionId, ...(active === undefined ? {} : { session: active.runtime.session, runtime: active.runtime }) });
+        }
+        await this.runTreeExclusiveOperation(targets, "Stop current session activity before changing session lifecycle", async () => {
+            const ready = [];
+            for (const item of idleItems) {
+                try {
+                    await this.closeActive(item.sessionId, { kind: "clear", reason }, scope);
+                    ready.push(item);
+                }
+                catch (error) {
+                    result.failures.push({ sessionId: item.sessionId, error: errorMessage(error) });
+                }
+            }
+            try {
+                const persistedIds = await persist(ready);
+                const readyById = new Map(ready.map((item) => [item.sessionId, item]));
+                result.successes = persistedIds.flatMap((sessionId) => {
+                    const item = readyById.get(sessionId);
+                    return item === undefined ? [] : [item];
+                });
+            }
+            catch (error) {
+                for (const item of ready)
+                    result.failures.push({ sessionId: item.sessionId, error: errorMessage(error) });
+            }
+            for (const item of result.successes)
+                this.workspaceActivity?.removeSession(item.sessionId, item.cwd, scope);
+            await this.forgetUnreadSessions(result.successes, scope);
+        });
+        return result;
+    }
     async archiveStoreArchiveMany(inputs) {
         if (inputs.length === 0)
             return [];
@@ -3048,6 +3261,9 @@ export class PiSessionService {
         return [...sessionIds];
     }
     async cleanupPlan(request) {
+        if (request.skipPinned === true && this.sessionPins === undefined)
+            throw new Error("Authoritative session pin store is unavailable");
+        const excludedPinnedSessionIds = request.skipPinned === true ? await this.sessionPins?.pinnedSessionIds() : undefined;
         const [sessions, archivedRecords, scopedSessions] = await Promise.all([
             this.sessionManager.listAll(),
             this.archiveStore.list(),
@@ -3060,6 +3276,7 @@ export class PiSessionService {
             archivedRecords,
             activeSessions: this.cleanupActiveSessionStatuses(),
             thresholds: request.thresholds,
+            ...(excludedPinnedSessionIds === undefined ? {} : { excludedPinnedSessionIds }),
             ...(request.projectCwds === undefined ? {} : { projectCwds: request.projectCwds }),
             now: this.now(),
         });
@@ -3191,6 +3408,10 @@ export class PiSessionService {
         this.events.mediaIndex.forgetSession({ id: sessionId, cwd: active.runtime.session.sessionManager.getCwd(), eventScope: active.eventScope });
         this.activities.delete(activeSessionKey(sessionId, active.eventScope));
         this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd(), active.eventScope);
+        const session = active.runtime.session;
+        if (sessionFileExists(session.sessionFile) && this.interventionRequired(session)) {
+            this.workspaceActivity?.applySessionIntervention(session.sessionManager.getCwd(), sessionId, true, active.eventScope);
+        }
         this.clearAuthLossWarningsForSession(sessionId);
         this.clearCompactionPromptQueue(active.runtime.session);
         // Disarm subsession notification before teardown so the abort below cannot
@@ -3445,7 +3666,7 @@ export class PiSessionService {
                         operation.error(message);
                         return;
                     }
-                    this.publishActivity(session, this.t("activity.extensionError", "Extension error"), "error", message);
+                    this.publishActivity(session, { kind: "extensionError" }, "error", message);
                     this.events.publish(session.sessionId, { type: "session.error", message }, owner.eventScope);
                 },
             });
@@ -3501,7 +3722,7 @@ export class PiSessionService {
                             if (current !== undefined && this.isCurrentActiveSession(current)) {
                                 const message = userFacingErrorMessage(error, this.t);
                                 current.extensionRunner.getUIContext().notify(message, "error");
-                                this.publishActivity(current, "extension callback failed", "error", message);
+                                this.publishActivity(current, { kind: "extensionCallbackFailed" }, "error", message);
                                 this.events.publish(current.sessionId, { type: "session.error", message }, this.eventScopeForSession(current));
                             }
                             throw error;
@@ -3554,12 +3775,17 @@ export class PiSessionService {
         }
         this.reconcileRuntimeMessageCount(session);
         this.restoreSubsessionReceipts(session);
+        this.interventionStates.set(session, sessionInterventionRequired(session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch()));
+        this.publishedSessionNames.set(session, { sessionId: session.sessionId, name: session.sessionName });
         const unsubscribe = session.subscribe((event) => {
             const eventType = getString(event, "type");
+            if (eventType === "session_info_changed")
+                this.publishSessionName(session);
             const message = getProperty(event, "message");
             const entry = getProperty(event, "entry");
             const inbox = this.subsessionInbox(session.sessionId, session.sessionFile, active.eventScope);
             if (eventType === "agent_start") {
+                this.setInterventionRequired(session, false);
                 this.restoreSubsessionReceipts(session, false);
                 this.subsessionStoppedParents.delete(session);
             }
@@ -3574,6 +3800,8 @@ export class PiSessionService {
             if (eventType === "agent_settled")
                 this.scheduleSubsessionDelivery(session);
             const role = getString(message, "role");
+            if (eventType === "message_end" && requestsHumanIntervention(message))
+                this.setInterventionRequired(session, true);
             if ((eventType === "message_end" && (role === "user" || role === "assistant" || role === "toolResult" || role === "system"))
                 || (eventType === "entry_appended" && getString(entry, "type") === "message")) {
                 this.runtimeMessageCounts.set(session, this.runtimeMessageCount(session) + 1);
@@ -3630,18 +3858,21 @@ export class PiSessionService {
         const aborted = getBoolean(event, "aborted") === true;
         const errorMessage = getString(event, "errorMessage");
         const automatic = getString(event, "reason") !== "manual";
-        const message = aborted
-            ? (automatic ? this.t("session.compaction.autoCancelled", "Automatic compaction cancelled.") : this.t("session.compaction.cancelled", "Compaction cancelled."))
-            : errorMessage === undefined ? undefined : this.t("session.compaction.failed", "Could not compact history. Try again.");
+        const presentation = aborted
+            ? { kind: automatic ? "automaticCompactionCancelled" : "compactionCancelled" }
+            : errorMessage === undefined ? undefined : { kind: "compactionFailed" };
+        const message = presentation === undefined ? undefined : sessionNotificationSources[presentation.kind];
         if (!aborted && errorMessage !== undefined) {
             this.events.publish(session.sessionId, { type: "session.diagnostic", message: errorMessage }, this.eventScopeForSession(session));
         }
-        this.publishActivity(session, aborted ? this.t("activity.compactionCancelled", "Compaction cancelled") : errorMessage === undefined ? this.t("activity.compacted", "Context compacted") : this.t("activity.compactionFailed", "Context compaction failed"), !aborted && errorMessage !== undefined ? "error" : "idle", message);
+        this.publishActivity(session, aborted
+            ? { kind: "compactionCancelled", detailKind: automatic ? "automaticCompactionCancelled" : "compactionCancelled" }
+            : errorMessage === undefined ? { kind: "compactionComplete" } : { kind: "compactionFailed", detailKind: "compactionFailed" }, !aborted && errorMessage !== undefined ? "error" : "idle", message);
         // Successful compaction already has a canonical summary in the transcript.
         // Keep cancellation/failure feedback in the refresh-safe session inbox only.
         const generation = this.notificationGenerationBySession.get(session);
         if (message !== undefined && generation !== undefined) {
-            this.publishNotificationMutations(this.notificationsForSession(session).addNotification(generation, message, aborted ? "info" : "error").mutations);
+            this.publishNotificationMutations(this.notificationsForSession(session).addNotification(generation, message, aborted ? "info" : "error", presentation).mutations);
         }
     }
     scheduleCompactionQueueDrain(session, delayMs = 0) {
@@ -3719,43 +3950,6 @@ export class PiSessionService {
             clearTimeout(timer);
         this.compactionDrainTimers.clear();
     }
-    maybeGenerateSessionName(session, firstMessage) {
-        if (session.sessionName !== undefined || session.messages.length !== 0 || session.isStreaming || session.isCompacting)
-            return;
-        void this.generateSessionName(session, firstMessage).then((name) => {
-            if (name === undefined)
-                this.logger.info({ sessionId: session.sessionId }, "Session naming returned no title; using the first-message fallback");
-            this.applyGeneratedSessionName(session, name ?? fallbackSessionName(firstMessage));
-        }).catch((error) => {
-            const errorCategory = error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") ? "timeout" : "generation";
-            this.logger.info({ sessionId: session.sessionId, errorCategory }, "Session naming failed; using the first-message fallback");
-            this.applyGeneratedSessionName(session, fallbackSessionName(firstMessage));
-        });
-    }
-    async generateSessionName(session, firstMessage) {
-        // One request keeps its settings even if the operator edits the config while it runs.
-        const naming = this.config === undefined ? {} : (await this.config.read()).effectiveConfig.sessionNaming ?? {};
-        let model = session.model;
-        if (naming.model !== undefined) {
-            const parsed = parseModelSpec(naming.model);
-            model = parsed === undefined ? undefined : session.modelRuntime.getModel(parsed.provider, parsed.modelId);
-            if (model === undefined)
-                throw new Error("Configured session naming model is unavailable");
-        }
-        if (model === undefined)
-            return undefined;
-        return generateShortSessionName(session.agent.streamFunction, model, firstMessage, naming);
-    }
-    applyGeneratedSessionName(session, name) {
-        if (name === undefined || session.sessionName !== undefined)
-            return;
-        if (this.treeNavigations.has(session)) {
-            this.deferredGeneratedSessionNames.set(session, name);
-            return;
-        }
-        session.setSessionName(name);
-        this.publishSessionName(session);
-    }
     applyAuthChange(change) {
         const changedRuntime = change.modelRuntime;
         for (const active of this.active.values()) {
@@ -3786,7 +3980,8 @@ export class PiSessionService {
         this.events.publish(session.sessionId, {
             type: "command.output",
             level: "error",
-            message: this.t("session.authRemoved", "Authentication for {provider}/{model} was removed. Use /model to select another model.", { provider: model.provider, model: model.id }),
+            message: `Authentication for ${model.provider}/${model.id} was removed. Use /model to select another model.`,
+            presentation: { kind: "modelAuthRemoved", provider: model.provider, model: model.id },
         }, eventScope);
     }
     clearAuthLossWarningsForSession(sessionId) {
@@ -3796,6 +3991,10 @@ export class PiSessionService {
         }
     }
     publishSessionName(session) {
+        const previous = this.publishedSessionNames.get(session);
+        if (previous?.sessionId === session.sessionId && previous.name === session.sessionName)
+            return;
+        this.publishedSessionNames.set(session, { sessionId: session.sessionId, name: session.sessionName });
         const event = session.sessionName === undefined
             ? { type: "session.name", sessionId: session.sessionId }
             : { type: "session.name", sessionId: session.sessionId, name: session.sessionName };
@@ -3819,25 +4018,25 @@ export class PiSessionService {
             }
             this.publishStatus(session);
             if (activity?.phase === "active")
-                this.publishActivity(session, activity.label, "active", activity.detail);
+                this.publishActivity(session, activity.runtimePresentation, "active", activity.detail);
             else
-                this.publishActivity(session, this.activityLabelFromStatus(session), "active");
+                this.publishActivity(session, this.activityPresentationFromStatus(session), "active");
         }
     }
-    activityLabelFromStatus(session) {
+    activityPresentationFromStatus(session) {
         if (this.treeNavigations.has(session))
-            return this.t("activity.navigating", "Navigating session tree");
+            return { kind: "navigatingTree" };
         if (this.isSessionEntryMutationActive(session))
-            return this.t("activity.updating", "Updating session");
+            return { kind: "updatingSession" };
         if (session.isCompacting)
-            return this.t("activity.compacting", "Compacting context");
+            return { kind: "compacting" };
         if (session.isBashRunning)
-            return this.t("activity.commandRunning", "Running command");
+            return { kind: "runningBash" };
         if (session.isStreaming)
-            return this.t("activity.agentRunning", "Agent running");
+            return { kind: "agentRunning" };
         if (this.pendingMessageCount(session) > 0)
-            return this.t("activity.queued", "Queued");
-        return this.t("activity.working", "Working");
+            return { kind: "queued" };
+        return { kind: "active" };
     }
     hasActiveWork(session) {
         const execution = this.extensionCommandExecution.getStore();
@@ -3942,56 +4141,56 @@ export class PiSessionService {
         if (eventType === undefined)
             return;
         if (eventType === "agent_start") {
-            this.publishActivity(session, this.t("activity.agentRunning", "Agent running"), "active");
+            this.publishActivity(session, { kind: "agentRunning" }, "active");
             return;
         }
         if (eventType === "agent_end") {
-            this.publishActivity(session, this.t("activity.idle", "Idle"), "idle");
+            this.publishActivity(session, { kind: "idle" }, "idle");
             const eventScope = this.eventScopeForSession(session);
             const sessionKey = activeSessionKey(session.sessionId, eventScope);
             this.activities.scheduleSettledRefresh(sessionKey, () => {
                 if (this.active.get(sessionKey)?.runtime.session !== session)
                     return;
-                this.publishActivity(session, this.t("activity.idle", "Idle"), "idle");
+                this.publishActivity(session, { kind: "idle" }, "idle");
                 this.publishStatus(session);
             }, 250);
             return;
         }
         if (eventType === "turn_end") {
-            this.publishActivity(session, this.t("activity.turnCompleted", "Turn completed"), "idle");
+            this.publishActivity(session, { kind: "turnComplete" }, "idle");
             return;
         }
         if (eventType === "message_start") {
-            this.publishActivity(session, this.t("activity.messageStarted", "Message started"), "active");
+            this.publishActivity(session, { kind: "messageStarted" }, "active");
             return;
         }
         if (eventType === "message_end") {
-            this.publishActivity(session, this.t("activity.messageCompleted", "Message completed"), "idle");
+            this.publishActivity(session, { kind: "messageComplete" }, "idle");
             return;
         }
         if (eventType === "message_update") {
-            this.publishActivity(session, this.t("activity.receiving", "Receiving reply"), "active");
+            this.publishActivity(session, { kind: "receivingResponse" }, "active");
             return;
         }
         if (eventType === "tool_execution_start") {
-            this.publishActivity(session, this.t("activity.toolRunning", "Running tool"), "active", getString(event, "toolName"));
+            this.publishActivity(session, { kind: "runningTool" }, "active", getString(event, "toolName"));
             return;
         }
         if (eventType === "tool_execution_end") {
             const isError = getBoolean(event, "isError") === true;
-            this.publishActivity(session, isError ? this.t("activity.toolFailed", "Tool failed") : this.t("activity.toolCompleted", "Tool completed"), isError ? "error" : "idle", getString(event, "toolName"));
+            this.publishActivity(session, isError ? { kind: "toolFailed" } : { kind: "toolComplete" }, isError ? "error" : "idle", getString(event, "toolName"));
             return;
         }
         if (eventType === "bash_execution_start") {
-            this.publishActivity(session, this.t("activity.commandRunning", "Running command"), "active");
+            this.publishActivity(session, { kind: "runningBash" }, "active");
             return;
         }
         if (eventType === "bash_execution_end") {
-            this.publishActivity(session, this.t("activity.commandCompleted", "Command completed"), "idle");
+            this.publishActivity(session, { kind: "bashComplete" }, "idle");
             return;
         }
         if (this.hasActiveWork(session))
-            this.publishActivity(session, this.t("activity.working", "Working"), "active");
+            this.publishActivity(session, { kind: "event", value: eventType }, "active");
     }
     auditToolExecutionEvent(active, event) {
         const eventType = getString(event, "type");
@@ -4088,23 +4287,23 @@ export class PiSessionService {
         const sessionId = sessionManager.getSessionId();
         if (sessionId === "")
             return { report: noop, end: noop };
-        const label = intent === "create" ? this.t("activity.creating", "Creating session") : this.t("activity.opening", "Opening session");
+        const label = intent === "create" ? "Creating session" : "Opening session";
         return {
-            report: (phase) => { this.publishStartupProgress(sessionId, startupToken, label, "active", this.startupDetail(phase), eventScope); },
+            report: (stage) => {
+                const catalogRefreshing = this.catalogRefreshStatus?.isRefreshInFlight() === true;
+                const phase = stage === "runtime" ? STARTUP_PHASE_RUNTIME : STARTUP_PHASE_EXTENSIONS;
+                const detail = catalogRefreshing ? `${phase} · ${STARTUP_CONCURRENT_CATALOG_REFRESH}` : phase;
+                this.publishStartupProgress(sessionId, startupToken, label, "active", detail, eventScope, { intent, stage, catalogRefreshing });
+            },
             end: () => {
                 // A real activity published during the window (an extension error, say)
                 // is the truth about this session and must survive the clear.
                 if (this.activities.get(activeSessionKey(sessionId, eventScope)) !== undefined)
                     return;
-                this.publishStartupProgress(sessionId, startupToken, this.t("activity.idle", "Idle"), "idle", undefined, eventScope);
+                this.publishStartupProgress(sessionId, startupToken, "Idle", "idle", undefined, eventScope);
             },
         };
     }
-    startupDetail(phase) {
-        return this.catalogRefreshStatus?.isRefreshInFlight() === true
-            ? `${phase} · ${this.t("startup.catalogRefresh", "Provider model catalog is refreshing")}`
-            : phase;
-    }
     /**
      * Report startup progress on the global channel only, echoing the caller's
      * correlation token so a waiting browser row recognises its own construction.
@@ -4118,17 +4317,21 @@ export class PiSessionService {
      * that sets the marker, and because it writes no `activities` entry no later
      * heartbeat re-publication can carry it.
      */
-    publishStartupProgress(sessionId, startupToken, label, phase, detail, eventScope) {
+    publishStartupProgress(sessionId, startupToken, label, phase, detail, eventScope, startupPresentation) {
         const at = new Date().toISOString();
-        const activity = detail === undefined ? { sessionId, phase, label, at, startup: true } : { sessionId, phase, label, detail, at, startup: true };
+        const activity = { sessionId, phase, label, at, startup: true,
+            ...(detail === undefined ? {} : { detail }),
+            ...(startupPresentation === undefined ? {} : { startupPresentation }),
+        };
         this.events.publishGlobal(startupToken === undefined ? { type: "session.startup", activity } : { type: "session.startup", startupToken, activity }, eventScope);
     }
-    publishActivity(session, label, phase, detail) {
+    publishActivity(session, runtimePresentation, phase, detail) {
         const at = new Date().toISOString();
-        const stored = detail === undefined ? { phase, label, at } : { phase, label, detail, at };
+        const label = runtimeActivityFallbackLabel(runtimePresentation);
+        const stored = { phase, label, at, runtimePresentation, ...(detail === undefined ? {} : { detail }) };
         const eventScope = this.eventScopeForSession(session);
         this.activities.set(activeSessionKey(session.sessionId, eventScope), stored);
-        const activity = detail === undefined ? { sessionId: session.sessionId, phase, label, at } : { sessionId: session.sessionId, phase, label, detail, at };
+        const activity = { sessionId: session.sessionId, ...stored };
         this.workspaceActivity?.applySessionActivity(session.sessionManager.getCwd(), activity, eventScope);
         this.events.publish(session.sessionId, { type: "activity.update", activity }, eventScope);
         this.events.publishGlobal({ type: "activity.update", activity }, eventScope);
@@ -4153,6 +4356,26 @@ export class PiSessionService {
         if (path !== undefined)
             this.managementMediaFiles.add(path);
     }
+    interventionRequired(session) {
+        return this.interventionStates.get(session)
+            ?? sessionInterventionRequired(session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch());
+    }
+    setInterventionRequired(session, required) {
+        const previous = this.interventionRequired(session);
+        if (previous === required)
+            return;
+        if (session.sessionManager.appendCustomEntry === undefined)
+            throw new Error("Session manager cannot persist intervention state");
+        // Update before append: the SDK emits entry_appended synchronously.
+        this.interventionStates.set(session, required);
+        try {
+            session.sessionManager.appendCustomEntry(SESSION_INTERVENTION_CUSTOM_TYPE, { version: 1, required });
+        }
+        catch (error) {
+            this.interventionStates.set(session, previous);
+            throw error;
+        }
+    }
     publishStatus(session) {
         this.rememberManagementMediaFile(session, this.eventScopeForSession(session));
         void this.refreshActivityMarker(session);
@@ -4170,7 +4393,7 @@ export class PiSessionService {
         if (current?.phase !== "active" || this.hasActiveWork(session))
             return;
         const at = new Date().toISOString();
-        const stored = { phase: "idle", label: this.t("activity.idle", "Idle"), at };
+        const stored = { phase: "idle", label: "idle", at, runtimePresentation: { kind: "idle" } };
         this.activities.set(activeSessionKey(session.sessionId, eventScope), stored);
         const activity = { sessionId: session.sessionId, ...stored };
         this.events.publish(session.sessionId, { type: "activity.update", activity }, eventScope);
@@ -4241,6 +4464,7 @@ export class PiSessionService {
             sessionId: session.sessionId,
             persisted: sessionFileExists(session.sessionFile),
             recentlyActiveElsewhere: this.eventScopeForSession(session) === NORMAL_SESSION_EVENT_SCOPE && this.activityMarker.isActiveElsewhere(session.sessionFile),
+            interventionRequired: this.interventionRequired(session) || pendingDialogs.length > 0,
             ...(model === undefined ? {} : { model }),
             thinkingLevel: session.thinkingLevel,
             isStreaming: session.isStreaming,
@@ -4322,8 +4546,22 @@ export class PiSessionService {
         return this.unreadForScope(eventScope).durableCatalogSnapshot();
     }
     async reconcileUnreadWorkspaces(cwds) {
+        this.unreadEligibilityRevision += 1;
         await this.publishUnreadMutations(this.unreadStore.reconcileWorkspaces(cwds));
     }
+    async markUnread(sessionId, cwd, context) {
+        const canonicalCwd = canonicalizeStoredCwd(cwd);
+        const eligibilityRevision = this.unreadEligibilityRevision;
+        const rows = await this.list(canonicalCwd, context);
+        const row = rows.find((candidate) => candidate.id === sessionId && cwdPathsEqual(candidate.cwd, canonicalCwd));
+        if (eligibilityRevision !== this.unreadEligibilityRevision
+            || row === undefined || row.archived === true || row.persisted !== true || row.agentSubsession === true) {
+            throw new Error("Session is not eligible to be marked unread");
+        }
+        const store = this.unreadForScope(eventScopeFromManagementContext(context));
+        await this.publishUnreadMutations(store.markUnread(sessionId, canonicalCwd));
+        return store.durableCatalogSnapshot();
+    }
     async acknowledgeUnread(sessionId, request, context) {
         const store = this.unreadForScope(eventScopeFromManagementContext(context));
         const result = store.acknowledge(sessionId, {
@@ -4353,7 +4591,7 @@ export class PiSessionService {
         if (this.hasActiveWork(session))
             throw new Error(this.t("session.stopBeforeReload", "Stop current session activity before reloading"));
         await this.runTreeExclusiveOperation([{ sessionId: session.sessionId, session }], this.t("session.stopBeforeReload", "Stop current session activity before reloading"), async () => {
-            this.publishActivity(session, this.t("activity.reloading", "Reloading resources"), "active");
+            this.publishActivity(session, { kind: "reloading" }, "active");
             const priorGeneration = this.notificationGenerationBySession.get(session);
             let candidateGeneration;
             const reloadBoundary = { beforeSessionStart: false };
@@ -4373,7 +4611,7 @@ export class PiSessionService {
                 if (candidateGeneration !== undefined) {
                     this.publishNotificationMutations(this.notificationsForSession(session).commitReplacement(candidateGeneration));
                 }
-                this.publishActivity(session, this.t("activity.reloaded", "Resources reloaded"), "idle");
+                this.publishActivity(session, { kind: "reloaded" }, "idle");
                 this.publishStatus(session);
             }
             catch (error) {
@@ -4384,7 +4622,7 @@ export class PiSessionService {
                     this.notificationGenerationBySession.set(session, candidateGeneration);
                 }
                 const message = error instanceof Error ? error.message : String(error);
-                this.publishActivity(session, this.t("activity.reloadFailed", "Reload failed"), "error", message);
+                this.publishActivity(session, { kind: "reloadFailed" }, "error", message);
                 this.events.publish(session.sessionId, { type: "session.error", message }, this.eventScopeForSession(session));
                 this.publishStatus(session);
                 throw error;
@@ -4404,7 +4642,7 @@ export class PiSessionService {
         return [...this.active.values()].some((active) => active.runtime.session === session);
     }
     async createSessionRuntime(sessionManager, cwd, options, startup) {
-        startup.report(this.t("startup.runtime", "Loading session runtime"));
+        startup.report("runtime");
         options.startupSignal?.throwIfAborted();
         // Ordinary local sessions (undefined provenance) keep the current rule.
         // Only an explicit host one-shot forces delegation off; do not treat every
@@ -4471,7 +4709,7 @@ export class PiSessionService {
                 await this.recoverSubsessionTrackingForOpenedSession(runtime.session);
             }
             startupSignal?.throwIfAborted();
-            startup.report(this.t("startup.extensions", "Starting session extensions"));
+            startup.report("extensions");
             // Startup hooks emit through the same scoped stream as hosted turns.
             this.bindRuntime(active);
             await this.bindSessionExtensions(runtime.session, notificationGeneration, active, startupSignal);
@@ -4626,12 +4864,15 @@ export class PiSessionService {
         const nextCwd = canonicalizeStoredCwd(next.sessionManager.getCwd());
         if (previous.sessionId === next.sessionId && cwdPathsEqual(previousCwd, nextCwd))
             return;
+        this.unreadEligibilityRevision += 1;
         await this.publishUnreadMutations(store.forgetSession(previous.sessionId, previousCwd));
     }
     forgetUnreadActivity(session) {
         this.unreadForScope(this.eventScopeForSession(session)).forgetActivity(session.sessionId, canonicalizeStoredCwd(session.sessionManager.getCwd()));
     }
     async forgetUnreadSessions(identities, scope = NORMAL_SESSION_EVENT_SCOPE) {
+        if (identities.length > 0)
+            this.unreadEligibilityRevision += 1;
         const mutations = [];
         for (const identity of identities) {
             mutations.push(...this.unreadForScope(scope).forgetSession(identity.sessionId, canonicalizeStoredCwd(identity.cwd)));
@@ -4735,16 +4976,6 @@ export class PiSessionService {
         this.unreadPublicationRetryDelayMs = this.unreadPublicationRetryInitialMs;
     }
     flushDeferredTreeNavigationWork(session) {
-        const generatedName = this.deferredGeneratedSessionNames.get(session);
-        this.deferredGeneratedSessionNames.delete(session);
-        if (generatedName !== undefined) {
-            try {
-                this.applyGeneratedSessionName(session, generatedName);
-            }
-            catch (error) {
-                this.logger.info({ sessionId: session.sessionId, error: error instanceof Error ? error.message : String(error) }, "failed to apply deferred session name");
-            }
-        }
         this.restoreSubsessionReceipts(session);
         this.scheduleSubsessionDelivery(session);
     }
@@ -4883,8 +5114,8 @@ export class PiSessionService {
         }, 0);
     }
     assertMcpModeAllowed(managementContext) {
-        if (VERSION !== "1.3.0")
-            throw new UserFacingError("mcpAuth.sdkUnsupported", "Dedicated MCP authentication requires Pi 1.3.0");
+        if (VERSION !== "1.3.0" && VERSION !== "1.4.0")
+            throw new UserFacingError("mcpAuth.sdkUnsupported", "Dedicated MCP authentication requires Pi 1.3.0 or 1.4.0");
         if (managementContext !== undefined && !managementUsesNormalPermissions(managementContext, { allowPrivileged: this.managementAllowPrivileged })) {
             throw new UserFacingError("mcpAuth.restrictedManagement", "MCP authentication is unavailable in restricted management mode");
         }
@@ -5034,6 +5265,7 @@ function previewResponseFromPlan(plan) {
         projects: plan.projects,
         totals: plan.totals,
         ...(plan.skippedBusySessionIds.length === 0 ? {} : { skippedBusySessionIds: plan.skippedBusySessionIds }),
+        ...(plan.skippedPinnedSessionIds === undefined ? {} : { skippedPinnedSessionIds: plan.skippedPinnedSessionIds }),
     };
 }
 function uniqueBulkSessionRefs(refs) {
@@ -5121,6 +5353,7 @@ function clientSessionFromListEntry(session) {
         modified: session.modified.toISOString(),
         messageCount: session.messageCount,
         firstMessage: clientSessionFirstMessagePreview(session.firstMessage),
+        ...(session.interventionRequired === true ? { interventionRequired: true } : {}),
         ...(session.parentSessionPath === undefined ? {} : { parentSessionPath: session.parentSessionPath }),
     };
 }