@nklisch/pi-enhanced 0.1.2 → 0.1.4

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/observation/notification.ts

@@ -6,6 +6,7 @@ import type { Subagent } from "#src/types";
 export interface NotificationDetails {
   id: string;
   description: string;
+  modelLabel: string;
   status: string;
   toolUses: number;
   turnCount: number;
@@ -19,9 +20,14 @@ export interface NotificationDetails {
 
 // ---- Pure helpers (exported for unit testing) ----
 
-/** Escape XML special characters to prevent injection in structured notifications. */
+/** Escape XML text and attribute delimiters in structured notifications. */
 export function escapeXml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
 }
 
 /** Human-readable status label for agent completion. */
@@ -49,7 +55,9 @@ export function formatTaskNotification(record: Subagent, resultMaxLen: number):
   const ctxXml = contextPercent !== null ? `<context_percent>${Math.round(contextPercent)}</context_percent>` : "";
   const compactXml = record.compactionCount ? `<compactions>${record.compactionCount}</compactions>` : "";
 
-  const resultPreview = record.result
+  const resultPreview = record.stoppedWhileQueued
+    ? "Agent was stopped while queued and never started. No work was performed."
+    : record.result
     ? record.result.length > resultMaxLen
       ? record.result.slice(0, resultMaxLen) + "\n...(truncated, use get_subagent_result for full output)"
       : record.result
@@ -63,6 +71,7 @@ export function formatTaskNotification(record: Subagent, resultMaxLen: number):
     toolCallId ? `<tool-use-id>${escapeXml(toolCallId)}</tool-use-id>` : null,
     outputFile ? `<output-file>${escapeXml(outputFile)}</output-file>` : null,
     `<status>${escapeXml(status)}</status>`,
+    `<model>${escapeXml(record.modelLabel)}</model>`,
     `<summary>Subagent "${escapeXml(record.description)}" ${record.status}</summary>`,
     `<result>${escapeXml(resultPreview)}</result>`,
     `<usage><total_tokens>${totalTokens}</total_tokens><tool_uses>${record.toolUses}</tool_uses>${ctxXml}${compactXml}<duration_ms>${durationMs}</duration_ms></usage>`,
@@ -82,6 +91,7 @@ export function buildNotificationDetails(
   return {
     id: record.id,
     description: record.description,
+    modelLabel: record.modelLabel,
     status: record.status,
     toolUses: record.toolUses,
     turnCount: record.turnCount,
@@ -90,7 +100,9 @@ export function buildNotificationDetails(
     durationMs: record.completedAt ? record.completedAt - record.startedAt : 0,
     outputFile: record.outputFile,
     error: record.error,
-    resultPreview: record.result
+    resultPreview: record.stoppedWhileQueued
+      ? "Agent was stopped while queued and never started. No work was performed."
+      : record.result
       ? record.result.length > resultMaxLen
         ? record.result.slice(0, resultMaxLen) + "…"
         : record.result
@@ -127,17 +139,12 @@ export interface NotificationSystem {
   dispose: () => void;
 }
 
-/** Delivery-consumption operation: get-result-tool's dependency on NotificationManager. */
-export interface ResultDelivery {
-  /** Record the parent consumed this agent's result: suppress its completion nudge. */
-  consume: (id: string) => void;
-}
-
-const NUDGE_HOLD_MS = 200;
-
-export class NotificationManager implements NotificationSystem, ResultDelivery {
-  private pendingNudges = new Map<string, ReturnType<typeof setTimeout>>();
-  private consumed = new Set<string>();
+export class NotificationManager implements NotificationSystem {
+  // Pi cannot recall a queued followUp. Hold records while the parent run is
+  // active so consumption can be rechecked at the actual delivery boundary.
+  private pendingNudges = new Map<string, Subagent>();
+  private parentRunActive = false;
+  private disposed = false;
 
   constructor(
     private sendMessage: (
@@ -146,51 +153,46 @@ export class NotificationManager implements NotificationSystem, ResultDelivery {
     ) => void,
   ) {}
 
-  consume(id: string): void {
-    this.consumed.add(id);
-    this.cancelNudge(id);
-  }
-
   sendCompletion(record: Subagent): void {
-    if (this.consumed.has(record.id)) return;
-    this.scheduleNudge(record.id, () => this.emitIndividualNudge(record));
+    if (this.disposed || record.consumed) return;
+    if (this.parentRunActive) {
+      this.pendingNudges.set(record.id, record);
+      return;
+    }
+    this.emitIndividualNudge(record);
   }
 
-  dispose(): void {
-    for (const timer of this.pendingNudges.values()) clearTimeout(timer);
-    this.pendingNudges.clear();
-    this.consumed.clear();
+  onParentAgentStart(): void {
+    if (!this.disposed) this.parentRunActive = true;
   }
 
-  private cancelNudge(key: string): void {
-    const timer = this.pendingNudges.get(key);
-    if (timer != null) {
-      clearTimeout(timer);
-      this.pendingNudges.delete(key);
+  onParentAgentSettled(): void {
+    if (this.disposed) return;
+    this.parentRunActive = false;
+    const withheld = [...this.pendingNudges.values()];
+    this.pendingNudges.clear();
+    for (const record of withheld) {
+      try {
+        this.emitIndividualNudge(record);
+      } catch (err) {
+        debugLog("notification render", err);
+      }
     }
   }
 
-  private scheduleNudge(key: string, send: () => void, delay = NUDGE_HOLD_MS): void {
-    this.cancelNudge(key);
-    this.pendingNudges.set(
-      key,
-      setTimeout(() => {
-        this.pendingNudges.delete(key);
-        try {
-          send();
-        } catch (err) {
-          debugLog("notification render", err);
-        }
-      }, delay),
-    );
+  dispose(): void {
+    this.disposed = true;
+    this.pendingNudges.clear();
   }
 
   private emitIndividualNudge(record: Subagent): void {
-    if (this.consumed.has(record.id)) return;
+    if (this.disposed || record.consumed) return;
 
     const notification = formatTaskNotification(record, 500);
     const outputFile = record.outputFile;
-    const footer = outputFile ? `\nFull transcript available at: ${outputFile}` : "";
+    const footer = !record.stoppedWhileQueued && outputFile
+      ? `\nFull transcript available at: ${outputFile}`
+      : "";
 
     this.sendMessage(
       {
@@ -201,5 +203,7 @@ export class NotificationManager implements NotificationSystem, ResultDelivery {
       },
       { deliverAs: "followUp", triggerTurn: true },
     );
+    // Push delivery collected the terminal outcome just as surely as a pull.
+    record.markConsumed();
   }
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/observation/renderer.ts

@@ -39,7 +39,7 @@ export function createNotificationRenderer() {
     let line = `${icon} ${theme.bold(d.description)} ${theme.fg("dim", statusText)}`;
 
     // Line 2: stats
-    const parts: string[] = [];
+    const parts: string[] = [d.modelLabel];
     if (d.turnCount > 0) parts.push(formatTurns(d.turnCount, d.maxTurns));
     if (d.toolUses > 0) parts.push(`${d.toolUses} tool use${d.toolUses === 1 ? "" : "s"}`);
     if (d.totalTokens > 0) parts.push(formatTokens(d.totalTokens));

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/observation/subagent-events-observer.ts

@@ -68,6 +68,21 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 		this.notifications.sendCompletion(record);
 	}
 
+	onSubagentResumed(record: Subagent): void {
+		const eventData = buildEventData(record);
+		this.emit("subagents:resumed", eventData);
+		this.appendEntry("subagents:record", {
+			id: record.id,
+			type: record.type,
+			description: record.description,
+			status: record.status,
+			result: record.result,
+			error: record.error,
+			startedAt: record.startedAt,
+			completedAt: record.completedAt,
+		});
+	}
+
 	onSubagentCompacted(record: Subagent, info: CompactionInfo): void {
 		// Emit compacted event when agent's session compacts (preserves count on record).
 		this.emit("subagents:compacted", {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/runtime.ts

@@ -18,6 +18,8 @@ import type { SessionContext } from "#src/types";
 export interface RunConfig {
   readonly defaultMaxTurns: number | undefined;
   readonly graceTurns: number;
+  readonly consumedSessionRetentionMinutes?: number;
+  readonly unconsumedSessionRetentionMinutes?: number;
 }
 
 /**

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/service/service-adapter.ts

@@ -6,6 +6,8 @@
  */
 
 import type { Model } from "@earendil-works/pi-ai";
+import { resolveDispatchAgentType } from "#src/config/agent-type-resolution";
+import type { AgentTypeRegistry } from "#src/config/agent-types";
 import type {
   SubagentLifecycleInterceptor,
   SubagentLifecycleRegistration,
@@ -13,8 +15,10 @@ import type {
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { WorkspaceProvider } from "#src/lifecycle/workspace";
 import type { SpawnOptions, SubagentRecord, SubagentsService } from "#src/service/service";
+import { formatModelLabel } from "#src/session/model-label";
 import type { ModelRegistry } from "#src/session/model-resolver";
-import type { SessionContext, Subagent } from "#src/types";
+import { resolveDefaultModel } from "#src/session/session-config";
+import type { AgentInvocation, SessionContext, Subagent } from "#src/types";
 
 /** Narrow interface for the SubagentManager — avoids coupling to the concrete class. */
 export interface SubagentManagerLike {
@@ -46,6 +50,8 @@ export class SubagentsServiceAdapter implements SubagentsService {
     private readonly manager: SubagentManagerLike,
     private readonly resolveModel: (input: string, registry: ModelRegistry) => Model<any> | string,
     private readonly runtime: ServiceRuntimeLike,
+    private readonly agentRegistry?: AgentTypeRegistry,
+    private readonly settings?: { readonly fallbackSubagent?: string | false },
   ) {}
 
   spawn(type: string, prompt: string, options?: SpawnOptions): string {
@@ -53,13 +59,28 @@ export class SubagentsServiceAdapter implements SubagentsService {
       throw new Error("No active session — cannot spawn agents outside a session.");
     }
 
-    const model = this.resolveModelOption(options?.model);
+    this.agentRegistry?.reload();
+    const resolution = this.agentRegistry
+      ? resolveDispatchAgentType(type, this.agentRegistry, this.settings?.fallbackSubagent)
+      : { type, requestedType: type, fellBack: false };
+    if ("error" in resolution) throw new Error(resolution.error);
+    const resolvedType = resolution.type;
+
+    const model = options?.model
+      ? this.resolveModelOption(options.model)
+      : this.resolveTypeDefaultModel(resolvedType);
     const description = options?.description ?? prompt.slice(0, 80);
     const isBackground = !(options?.foreground ?? false);
+    const invocation: AgentInvocation = {
+      modelName: formatModelLabel(model),
+      maxTurns: options?.maxTurns,
+      inheritContext: options?.inheritContext,
+      runInBackground: isBackground,
+    };
 
     const snapshot = this.runtime.buildSnapshot(options?.inheritContext ?? false);
     const parent = this.runtime.getSessionInfo();
-    return this.manager.spawn(snapshot, type, prompt, {
+    return this.manager.spawn(snapshot, resolvedType, prompt, {
       description,
       model,
       maxTurns: options?.maxTurns,
@@ -68,6 +89,7 @@ export class SubagentsServiceAdapter implements SubagentsService {
       bypassQueue: options?.bypassQueue,
       isBackground,
       origin: "service",
+      invocation,
       lifecycleParentSession: parent.parentSessionId
         ? {
             parentSessionFile: parent.parentSessionFile || undefined,
@@ -117,9 +139,8 @@ export class SubagentsServiceAdapter implements SubagentsService {
     return this.manager.registerLifecycleInterceptor(interceptor);
   }
 
-  /** Resolve an optional model-string override against the current session's registry. */
-  private resolveModelOption(modelInput: string | undefined): Model<any> | undefined {
-    if (!modelInput) return undefined;
+  /** Resolve a model-string override against the current session's registry. */
+  private resolveModelOption(modelInput: string): Model<any> {
     const registry = this.runtime.currentCtx?.modelRegistry;
     if (!registry) {
       throw new Error("No model registry available.");
@@ -130,6 +151,14 @@ export class SubagentsServiceAdapter implements SubagentsService {
     }
     return resolved;
   }
+
+  /** Resolve the agent type's configured model with the same fallback used by session assembly. */
+  private resolveTypeDefaultModel(type: string): Model<any> {
+    const ctx = this.runtime.currentCtx!;
+    const configured = this.agentRegistry?.resolveAgentConfig(type).model;
+    if (!ctx.modelRegistry) return ctx.model as Model<any>;
+    return resolveDefaultModel(ctx.model, ctx.modelRegistry, configured) as Model<any>;
+  }
 }
 
 /**

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/service/service.ts

@@ -125,6 +125,7 @@ export interface SubagentsService {
 export const SUBAGENT_EVENTS = {
   STARTED: "subagents:started",
   COMPLETED: "subagents:completed",
+  RESUMED: "subagents:resumed",
   FAILED: "subagents:failed",
   COMPACTED: "subagents:compacted",
   CREATED: "subagents:created",

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/model-label.ts

@@ -0,0 +1,19 @@
+import type { Model } from "@earendil-works/pi-ai";
+
+/**
+ * Return the exact display identity for a resolved model.
+ *
+ * Pi identifies models by provider and id. The human-readable `name` is not
+ * unique across providers, so operator status surfaces use `provider/id`.
+ */
+export function formatModelLabel(model: unknown): string {
+  if (isModelIdentity(model)) return `${model.provider}/${model.id}`;
+  return "unknown model";
+}
+
+function isModelIdentity(value: unknown): value is Pick<Model<any>, "provider" | "id"> {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as { provider?: unknown; id?: unknown };
+  return typeof candidate.provider === "string" && candidate.provider.length > 0
+    && typeof candidate.id === "string" && candidate.id.length > 0;
+}

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/prompts.ts

@@ -27,12 +27,14 @@ import type { AgentPromptConfig } from "#src/types";
  * The tag follows the cacheable parent prefix in both modes.
  *
  * @param parentSystemPrompt  The parent agent's effective system prompt.
+ * @param parentCwd           Parent cwd used to remove a contradictory Pi footer.
  */
 export function buildAgentPrompt(
   config: AgentPromptConfig,
   cwd: string,
   env: EnvInfo,
   parentSystemPrompt?: string,
+  parentCwd?: string,
 ): string {
   const activeAgentTag = `<active_agent name="${config.name}"/>\n\n`;
 
@@ -41,7 +43,9 @@ Working directory: ${cwd}
 ${env.isGitRepo ? `Git repository: yes\nBranch: ${env.branch}` : "Not a git repository"}
 Platform: ${env.platform}`;
 
-  const identity = parentSystemPrompt ?? genericBase;
+  const identity = parentSystemPrompt
+    ? withoutContradictoryCwdFooter(parentSystemPrompt, parentCwd, cwd)
+    : genericBase;
 
   if (config.promptMode === "append") {
 
@@ -85,6 +89,25 @@ You are operating as a sub-agent invoked to handle a specific task.
   return identity + "\n\n" + activeAgentTag + envBlock + "\n\n" + config.systemPrompt;
 }
 
+/**
+ * Pi appends an authoritative cwd line to the parent prompt. A workspace-backed
+ * child appends its own environment block, so retain that footer only when both
+ * sessions actually share a directory.
+ */
+function withoutContradictoryCwdFooter(
+  prompt: string,
+  parentCwd: string | undefined,
+  childCwd: string,
+): string {
+  if (!parentCwd || toPromptPath(parentCwd) === toPromptPath(childCwd)) return prompt;
+  const footerLine = `Current working directory: ${toPromptPath(parentCwd)}`;
+  return prompt.split("\n").filter((line) => line !== footerLine).join("\n");
+}
+
+function toPromptPath(cwd: string): string {
+  return cwd.replaceAll("\\", "/");
+}
+
 /** Fallback base prompt when parent system prompt is unavailable (both modes). */
 const genericBase = `# Role
 You are a general-purpose coding agent for complex, multi-step tasks.

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/session-config.ts

@@ -10,7 +10,7 @@
  * before invoking this function, keeping the assembler synchronous.
  */
 
-import type { AgentConfigLookup } from "#src/config/agent-types";
+import { type AgentConfigLookup, BUILTIN_TOOL_NAMES } from "#src/config/agent-types";
 import type { EnvInfo } from "#src/session/env";
 import type { AgentPromptConfig, SubagentType, ThinkingLevel } from "#src/types";
 
@@ -30,6 +30,7 @@ export interface AssemblerIO {
     cwd: string,
     env: EnvInfo,
     parentPrompt?: string,
+    parentCwd?: string,
   ) => string;
 }
 
@@ -79,8 +80,8 @@ export interface SessionConfig {
   effectiveCwd: string;
   /** Fully-assembled system prompt string (ready for `systemPromptOverride`). */
   systemPrompt: string;
-  /** Built-in tool name allowlist for this agent type. */
-  toolNames: string[];
+  /** Built-in tools denied to this agent; extension tools remain inheritable. */
+  excludedBuiltinToolNames: string[];
   /**
    * Resolved model instance (undefined → use parent model as passed to SDK).
    * Opaque handle — the assembler passes it through without inspection.
@@ -102,7 +103,7 @@ export interface SessionConfig {
  * string that resolves against the registry AND is in the available set, return
  * that model instead.
  */
-function resolveDefaultModel(
+export function resolveDefaultModel(
   parentModel: unknown,
   registry: AssemblerContext["modelRegistry"],
   configModel?: string,
@@ -155,7 +156,10 @@ export function assembleSessionConfig(
 
   const effectiveCwd = options.cwd ?? ctx.cwd;
 
-  const toolNames = registry.getToolNamesForType(type);
+  const enabledBuiltinTools = new Set(registry.getToolNamesForType(type));
+  const excludedBuiltinToolNames = BUILTIN_TOOL_NAMES.filter(
+    (name) => !enabledBuiltinTools.has(name),
+  );
 
   // Build system prompt from the resolved agent config
   const systemPrompt = io.buildAgentPrompt(
@@ -163,6 +167,7 @@ export function assembleSessionConfig(
     effectiveCwd,
     env,
     ctx.parentSystemPrompt,
+    ctx.cwd,
   );
 
   // Model resolution: explicit option > config model string > parent model
@@ -179,7 +184,7 @@ export function assembleSessionConfig(
   return {
     effectiveCwd,
     systemPrompt,
-    toolNames,
+    excludedBuiltinToolNames,
     model,
     thinkingLevel,
     agentMaxTurns,

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/settings.ts

@@ -1,6 +1,6 @@
 // Persistence for pi-subagents operational settings.
 // - Global:  ~/.pi/agent/subagents.json (agentDir injected at construction) — manual defaults, never written here
-// - Project: <cwd>/.pi/subagents.json — written by /agents → Settings; overrides global on load
+// - Project: <cwd>/.pi/subagents.json — written by /subagents:settings; overrides global on load
 
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -14,6 +14,11 @@ export interface SubagentsSettings {
    */
   defaultMaxTurns?: number;
   graceTurns?: number;
+  consumedSessionRetentionMinutes?: number;
+  unconsumedSessionRetentionMinutes?: number;
+  abortAllOnInterrupt?: boolean;
+  /** false or "none" fails closed; an agent name selects an explicit fallback. */
+  fallbackSubagent?: string | false;
 }
 
 
@@ -22,15 +27,21 @@ export type SettingsEmit = (event: string, payload: unknown) => void;
 
 const DEFAULT_MAX_CONCURRENT = 4;
 const DEFAULT_GRACE_TURNS = 5;
+const DEFAULT_CONSUMED_RETENTION_MINUTES = 10;
+const DEFAULT_UNCONSUMED_RETENTION_MINUTES = 720;
 
 /**
- * Owns all three in-memory settings values and their load/save/persist cycle.
+ * Owns runtime settings and their load/save/persist cycle.
  * Replaces the scattered free-function + SettingsAppliers callback pattern.
  */
 export class SettingsManager {
   private _defaultMaxTurns: number | undefined = undefined;
   private _graceTurns: number = DEFAULT_GRACE_TURNS;
   private _maxConcurrent: number = DEFAULT_MAX_CONCURRENT;
+  private _consumedSessionRetentionMinutes = DEFAULT_CONSUMED_RETENTION_MINUTES;
+  private _unconsumedSessionRetentionMinutes = DEFAULT_UNCONSUMED_RETENTION_MINUTES;
+  private _abortAllOnInterrupt = true;
+  private _fallbackSubagent: string | false | undefined;
 
   private readonly emit: SettingsEmit;
   private readonly cwd: string;
@@ -78,6 +89,22 @@ export class SettingsManager {
     this._maxConcurrent = Math.max(1, n);
   }
 
+  get consumedSessionRetentionMinutes(): number { return this._consumedSessionRetentionMinutes; }
+  set consumedSessionRetentionMinutes(n: number) { this._consumedSessionRetentionMinutes = Math.max(0, n); }
+
+  get unconsumedSessionRetentionMinutes(): number { return this._unconsumedSessionRetentionMinutes; }
+  set unconsumedSessionRetentionMinutes(n: number) { this._unconsumedSessionRetentionMinutes = Math.max(0, n); }
+
+  get abortAllOnInterrupt(): boolean { return this._abortAllOnInterrupt; }
+  set abortAllOnInterrupt(value: boolean) { this._abortAllOnInterrupt = value; }
+
+  get fallbackSubagent(): string | false | undefined { return this._fallbackSubagent; }
+  set fallbackSubagent(value: string | false | undefined) {
+    this._fallbackSubagent = value === false || value === "none"
+      ? false
+      : typeof value === "string" && value.trim() ? value.trim() : undefined;
+  }
+
   // ── Lifecycle methods ──
 
   /**
@@ -90,6 +117,10 @@ export class SettingsManager {
     if (typeof settings.maxConcurrent === "number") this.maxConcurrent = settings.maxConcurrent;
     if (typeof settings.defaultMaxTurns === "number") this.defaultMaxTurns = settings.defaultMaxTurns;
     if (typeof settings.graceTurns === "number") this.graceTurns = settings.graceTurns;
+    if (typeof settings.consumedSessionRetentionMinutes === "number") this.consumedSessionRetentionMinutes = settings.consumedSessionRetentionMinutes;
+    if (typeof settings.unconsumedSessionRetentionMinutes === "number") this.unconsumedSessionRetentionMinutes = settings.unconsumedSessionRetentionMinutes;
+    if (typeof settings.abortAllOnInterrupt === "boolean") this.abortAllOnInterrupt = settings.abortAllOnInterrupt;
+    if (settings.fallbackSubagent !== undefined) this.fallbackSubagent = settings.fallbackSubagent;
     this.emit("subagents:settings_loaded", { settings });
     return settings;
   }
@@ -98,11 +129,15 @@ export class SettingsManager {
    * Snapshot current in-memory values for persistence.
    * `defaultMaxTurns` uses 0 as the on-disk marker for unlimited (undefined).
    */
-  snapshot(): { maxConcurrent: number; defaultMaxTurns: number; graceTurns: number } {
+  snapshot(): Required<SubagentsSettings> {
     return {
       maxConcurrent: this._maxConcurrent,
       defaultMaxTurns: this._defaultMaxTurns ?? 0,
       graceTurns: this._graceTurns,
+      consumedSessionRetentionMinutes: this._consumedSessionRetentionMinutes,
+      unconsumedSessionRetentionMinutes: this._unconsumedSessionRetentionMinutes,
+      abortAllOnInterrupt: this._abortAllOnInterrupt,
+      fallbackSubagent: this._fallbackSubagent ?? "general-purpose",
     };
   }
 
@@ -134,6 +169,27 @@ export class SettingsManager {
     return this.saveAndNotify(`Grace turns set to ${this.graceTurns}`);
   }
 
+  applyConsumedSessionRetention(n: number): { message: string; level: "info" | "warning" } {
+    this.consumedSessionRetentionMinutes = n;
+    return this.saveAndNotify(`Consumed session retention set to ${this.consumedSessionRetentionMinutes} minutes`);
+  }
+
+  applyUnconsumedSessionRetention(n: number): { message: string; level: "info" | "warning" } {
+    this.unconsumedSessionRetentionMinutes = n;
+    return this.saveAndNotify(`Unconsumed session retention set to ${this.unconsumedSessionRetentionMinutes} minutes`);
+  }
+
+  applyAbortAllOnInterrupt(value: boolean): { message: string; level: "info" | "warning" } {
+    this.abortAllOnInterrupt = value;
+    return this.saveAndNotify(`Abort all subagents on ESC ${value ? "enabled" : "disabled"}`);
+  }
+
+  applyFallbackSubagent(value: string | false | undefined): { message: string; level: "info" | "warning" } {
+    this.fallbackSubagent = value;
+    const label = this.fallbackSubagent === false ? "none (fail closed)" : this.fallbackSubagent ?? "general-purpose";
+    return this.saveAndNotify(`Unknown agent fallback set to ${label}`);
+  }
+
   /**
    * Persist the current snapshot, emit `subagents:settings_changed`,
    * and return the toast the UI should display.
@@ -152,6 +208,7 @@ export class SettingsManager {
 const MAX_CONCURRENT_CEILING = 1024;
 const MAX_TURNS_CEILING = 10_000;
 const GRACE_TURNS_CEILING = 1_000;
+const RETENTION_MINUTES_CEILING = 60 * 24 * 365;
 
 /** Drop fields that don't match the expected shape. Silent — garbage becomes absent. */
 function sanitize(raw: unknown): SubagentsSettings {
@@ -179,6 +236,16 @@ function sanitize(raw: unknown): SubagentsSettings {
   ) {
     out.graceTurns = r.graceTurns as number;
   }
+  for (const key of ["consumedSessionRetentionMinutes", "unconsumedSessionRetentionMinutes"] as const) {
+    if (Number.isInteger(r[key]) && (r[key] as number) >= 0 && (r[key] as number) <= RETENTION_MINUTES_CEILING) {
+      out[key] = r[key] as number;
+    }
+  }
+  if (typeof r.abortAllOnInterrupt === "boolean") out.abortAllOnInterrupt = r.abortAllOnInterrupt;
+  if (r.fallbackSubagent === false || r.fallbackSubagent === "none") out.fallbackSubagent = false;
+  else if (typeof r.fallbackSubagent === "string" && r.fallbackSubagent.trim()) {
+    out.fallbackSubagent = r.fallbackSubagent.trim();
+  }
   return out;
 }