@gotgenes/pi-subagents 5.1.0 → 5.3.0

package/src/agent-manager.ts

@@ -11,6 +11,7 @@ import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resumeAgent, runAgent, type ToolActivity } from "./agent-runner.js";
 import { debugLog } from "./debug.js";
+import type { RunConfig } from "./runtime.js";
 import type { AgentInvocation, AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
 import { addUsage } from "./usage.js";
 import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
@@ -72,6 +73,7 @@ export class AgentManager {
   private onStart?: OnAgentStart;
   private onCompact?: OnAgentCompact;
   private maxConcurrent: number;
+  private getRunConfig?: () => RunConfig;
 
   /** Queue of background agents waiting to start. */
   private queue: { id: string; args: SpawnArgs }[] = [];
@@ -83,10 +85,12 @@ export class AgentManager {
     maxConcurrent = DEFAULT_MAX_CONCURRENT,
     onStart?: OnAgentStart,
     onCompact?: OnAgentCompact,
+    getRunConfig?: () => RunConfig,
   ) {
     this.onComplete = onComplete;
     this.onStart = onStart;
     this.onCompact = onCompact;
+    this.getRunConfig = getRunConfig;
     this.maxConcurrent = maxConcurrent;
     // Cleanup completed agents after 10 minutes (but keep sessions for resume)
     this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
@@ -182,10 +186,13 @@ export class AgentManager {
     }
     const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
 
+    const runConfig = this.getRunConfig?.();
     const promise = runAgent(ctx, type, prompt, {
       pi,
       model: options.model,
       maxTurns: options.maxTurns,
+      defaultMaxTurns: runConfig?.defaultMaxTurns,
+      graceTurns: runConfig?.graceTurns,
       isolated: options.isolated,
       inheritContext: options.inheritContext,
       thinkingLevel: options.thinkingLevel,

package/src/agent-runner.ts

@@ -14,19 +14,9 @@ import {
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
-import {
-  getAgentConfig,
-  getConfig,
-  getMemoryToolNames,
-  getReadOnlyMemoryToolNames,
-  getToolNamesForType,
-} from "./agent-types.js";
 import { buildParentContext, extractText } from "./context.js";
-import { DEFAULT_AGENTS } from "./default-agents.js";
 import { detectEnv } from "./env.js";
-import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
-import { buildAgentPrompt, type PromptExtras } from "./prompts.js";
-import { preloadSkills } from "./skill-loader.js";
+import { assembleSessionConfig } from "./session-config.js";
 import type { SubagentType, ThinkingLevel } from "./types.js";
 
 /** Names of tools registered by this extension that subagents must NOT inherit. */
@@ -68,69 +58,12 @@ function filterActiveTools(
   });
 }
 
-/** Default max turns. undefined = unlimited (no turn limit). */
-let defaultMaxTurns: number | undefined;
-
 /** Normalize max turns. undefined or 0 = unlimited, otherwise minimum 1. */
 export function normalizeMaxTurns(n: number | undefined): number | undefined {
   if (n == null || n === 0) return undefined;
   return Math.max(1, n);
 }
 
-/** Get the default max turns value. undefined = unlimited. */
-export function getDefaultMaxTurns(): number | undefined {
-  return defaultMaxTurns;
-}
-/** Set the default max turns value. undefined or 0 = unlimited, otherwise minimum 1. */
-export function setDefaultMaxTurns(n: number | undefined): void {
-  defaultMaxTurns = normalizeMaxTurns(n);
-}
-
-/** Additional turns allowed after the soft limit steer message. */
-let graceTurns = 5;
-
-/** Get the grace turns value. */
-export function getGraceTurns(): number {
-  return graceTurns;
-}
-/** Set the grace turns value (minimum 1). */
-export function setGraceTurns(n: number): void {
-  graceTurns = Math.max(1, n);
-}
-
-/**
- * Try to find the right model for an agent type.
- * Priority: explicit option > config.model > parent model.
- */
-function resolveDefaultModel(
-  parentModel: Model<any> | undefined,
-  registry: {
-    find(provider: string, modelId: string): Model<any> | undefined;
-    getAvailable?(): Model<any>[];
-  },
-  configModel?: string,
-): Model<any> | undefined {
-  if (configModel) {
-    const slashIdx = configModel.indexOf("/");
-    if (slashIdx !== -1) {
-      const provider = configModel.slice(0, slashIdx);
-      const modelId = configModel.slice(slashIdx + 1);
-
-      // Build a set of available model keys for fast lookup
-      const available = registry.getAvailable?.();
-      const availableKeys = available
-        ? new Set(available.map((m: any) => `${m.provider}/${m.id}`))
-        : undefined;
-      const isAvailable = (p: string, id: string) =>
-        !availableKeys || availableKeys.has(`${p}/${id}`);
-
-      const found = registry.find(provider, modelId);
-      if (found && isAvailable(provider, modelId)) return found;
-    }
-  }
-
-  return parentModel;
-}
 
 /** Info about a tool event in the subagent. */
 export interface ToolActivity {
@@ -174,6 +107,17 @@ export interface RunOptions {
     reason: "manual" | "threshold" | "overflow";
     tokensBefore: number;
   }) => void;
+  /**
+   * Default max turns from runtime config. Falls back to the module-scope
+   * `defaultMaxTurns` during the lift-and-shift migration; superseded by
+   * per-call `maxTurns` and per-agent `agentConfig.maxTurns`.
+   */
+  defaultMaxTurns?: number;
+  /**
+   * Grace turns after the soft-limit steer message. Falls back to the
+   * module-scope `graceTurns` during migration.
+   */
+  graceTurns?: number;
 }
 
 export interface RunResult {
@@ -236,96 +180,27 @@ export async function runAgent(
   prompt: string,
   options: RunOptions,
 ): Promise<RunResult> {
-  const config = getConfig(type);
-  const agentConfig = getAgentConfig(type);
-
-  // Resolve working directory: worktree override > parent cwd
+  // Resolve working directory upfront — needed for detectEnv before assembly.
   const effectiveCwd = options.cwd ?? ctx.cwd;
-
   const env = await detectEnv(options.pi, effectiveCwd);
 
-  // Get parent system prompt for append-mode agents
-  const parentSystemPrompt = ctx.getSystemPrompt();
-
-  // Build prompt extras (memory, skill preloading)
-  const extras: PromptExtras = {};
-
-  // Resolve extensions/skills: isolated overrides to false
-  const extensions = options.isolated ? false : config.extensions;
-  const skills = options.isolated ? false : config.skills;
-
-  // Skill preloading: when skills is string[], preload their content into prompt
-  if (Array.isArray(skills)) {
-    const loaded = preloadSkills(skills, effectiveCwd);
-    if (loaded.length > 0) {
-      extras.skillBlocks = loaded;
-    }
-  }
-
-  let toolNames = getToolNamesForType(type);
-
-  // Persistent memory: detect write capability and branch accordingly.
-  // Account for disallowedTools — a tool in the base set but on the denylist is not truly available.
-  if (agentConfig?.memory) {
-    const existingNames = new Set(toolNames);
-    const denied = agentConfig.disallowedTools
-      ? new Set(agentConfig.disallowedTools)
-      : undefined;
-    const effectivelyHas = (name: string) =>
-      existingNames.has(name) && !denied?.has(name);
-    const hasWriteTools = effectivelyHas("write") || effectivelyHas("edit");
-
-    if (hasWriteTools) {
-      // Read-write memory: add any missing memory tool names (read/write/edit)
-      const extraNames = getMemoryToolNames(existingNames);
-      if (extraNames.length > 0) toolNames = [...toolNames, ...extraNames];
-      extras.memoryBlock = buildMemoryBlock(
-        agentConfig.name,
-        agentConfig.memory,
-        effectiveCwd,
-      );
-    } else {
-      // Read-only memory: only add read tool name, use read-only prompt
-      const extraNames = getReadOnlyMemoryToolNames(existingNames);
-      if (extraNames.length > 0) toolNames = [...toolNames, ...extraNames];
-      extras.memoryBlock = buildReadOnlyMemoryBlock(
-        agentConfig.name,
-        agentConfig.memory,
-        effectiveCwd,
-      );
-    }
-  }
-
-  // Build system prompt from agent config
-  let systemPrompt: string;
-  if (agentConfig) {
-    systemPrompt = buildAgentPrompt(
-      agentConfig,
-      effectiveCwd,
-      env,
-      parentSystemPrompt,
-      extras,
-    );
-  } else {
-    // Unknown type fallback: spread the canonical general-purpose config (defensive —
-    // unreachable in practice since index.ts resolves unknown types before calling runAgent).
-    const fallback = DEFAULT_AGENTS.get("general-purpose");
-    if (!fallback)
-      throw new Error(
-        `No fallback config available for unknown type "${type}"`,
-      );
-    systemPrompt = buildAgentPrompt(
-      { ...fallback, name: type },
-      effectiveCwd,
-      env,
-      parentSystemPrompt,
-      extras,
-    );
-  }
-
-  // When skills is string[], we've already preloaded them into the prompt.
-  // Still pass noSkills: true since we don't need the skill loader to load them again.
-  const noSkills = skills === false || Array.isArray(skills);
+  // Assemble session configuration (synchronous, no SDK objects).
+  const cfg = assembleSessionConfig(
+    type,
+    {
+      cwd: ctx.cwd,
+      parentSystemPrompt: ctx.getSystemPrompt(),
+      parentModel: ctx.model,
+      modelRegistry: ctx.modelRegistry,
+    },
+    {
+      cwd: options.cwd,
+      isolated: options.isolated,
+      model: options.model,
+      thinkingLevel: options.thinkingLevel,
+    },
+    env,
+  );
 
   const agentDir = getAgentDir();
 
@@ -336,56 +211,43 @@ export async function runAgent(
   // wanted, reaches the subagent via prompt_mode: append (parentSystemPrompt
   // is embedded in systemPromptOverride) or inherit_context (conversation).
   const loader = new DefaultResourceLoader({
-    cwd: effectiveCwd,
+    cwd: cfg.effectiveCwd,
     agentDir,
-    noExtensions: extensions === false,
-    noSkills,
+    noExtensions: cfg.extensions === false,
+    noSkills: cfg.noSkills,
     noPromptTemplates: true,
     noThemes: true,
     noContextFiles: true,
-    systemPromptOverride: () => systemPrompt,
+    systemPromptOverride: () => cfg.systemPrompt,
     appendSystemPromptOverride: () => [],
   });
   await loader.reload();
 
-  // Resolve model: explicit option > config.model > parent model
-  const model =
-    options.model ??
-    resolveDefaultModel(ctx.model, ctx.modelRegistry, agentConfig?.model);
-
-  // Resolve thinking level: explicit option > agent config > undefined (inherit)
-  const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking;
-
   const sessionOpts: Parameters<typeof createAgentSession>[0] = {
-    cwd: effectiveCwd,
+    cwd: cfg.effectiveCwd,
     agentDir,
-    sessionManager: SessionManager.inMemory(effectiveCwd),
-    settingsManager: SettingsManager.create(effectiveCwd, agentDir),
+    sessionManager: SessionManager.inMemory(cfg.effectiveCwd),
+    settingsManager: SettingsManager.create(cfg.effectiveCwd, agentDir),
     modelRegistry: ctx.modelRegistry,
-    model,
-    tools: toolNames,
+    model: cfg.model as Model<any> | undefined,
+    tools: cfg.toolNames,
     resourceLoader: loader,
   };
-  if (thinkingLevel) {
-    sessionOpts.thinkingLevel = thinkingLevel;
+  if (cfg.thinkingLevel) {
+    sessionOpts.thinkingLevel = cfg.thinkingLevel;
   }
 
   const { session } = await createAgentSession(sessionOpts);
 
-  // Build disallowed tools set from agent config
-  const disallowedSet = agentConfig?.disallowedTools
-    ? new Set(agentConfig.disallowedTools)
-    : undefined;
-
   // Filter active tools: remove our own tools to prevent nesting,
   // apply extension allowlist if specified, and apply disallowedTools denylist.
   // First pass — over built-in tools, before bindExtensions registers extension tools.
-  if (extensions !== false || disallowedSet) {
+  if (cfg.extensions !== false || cfg.disallowedSet) {
     const filtered = filterActiveTools(
       session.getActiveToolNames(),
-      toolNames,
-      extensions,
-      disallowedSet,
+      cfg.toolNames,
+      cfg.extensions,
+      cfg.disallowedSet,
     );
     session.setActiveToolsByName(filtered);
   }
@@ -409,12 +271,12 @@ export async function runAgent(
   // re-filter, the `extensions: string[]` allowlist branch never matches any
   // extension tools and `extensions: true` lets non-allowlisted denylist
   // entries slip in. Run the same filter against the post-bind active set.
-  if (extensions !== false || disallowedSet) {
+  if (cfg.extensions !== false || cfg.disallowedSet) {
     const refiltered = filterActiveTools(
       session.getActiveToolNames(),
-      toolNames,
-      extensions,
-      disallowedSet,
+      cfg.toolNames,
+      cfg.extensions,
+      cfg.disallowedSet,
     );
     session.setActiveToolsByName(refiltered);
   }
@@ -424,7 +286,7 @@ export async function runAgent(
   // Track turns for graceful max_turns enforcement
   let turnCount = 0;
   const maxTurns = normalizeMaxTurns(
-    options.maxTurns ?? agentConfig?.maxTurns ?? defaultMaxTurns,
+    options.maxTurns ?? cfg.agentMaxTurns ?? options.defaultMaxTurns,
   );
   let softLimitReached = false;
   let aborted = false;
@@ -440,7 +302,7 @@ export async function runAgent(
           session.steer(
             "You have reached your turn limit. Wrap up immediately — provide your final answer now.",
           );
-        } else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
+        } else if (softLimitReached && turnCount >= maxTurns + (options.graceTurns ?? 5)) {
           aborted = true;
           session.abort();
         }

package/src/debug.ts

@@ -5,8 +5,10 @@
  * throughout the package. Production behavior is unchanged when unset.
  */
 
-export const DEBUG = process.env.PI_SUBAGENTS_DEBUG === "1";
+export function isDebug(): boolean {
+  return process.env.PI_SUBAGENTS_DEBUG === "1";
+}
 
 export function debugLog(context: string, err: unknown): void {
-  if (DEBUG) console.warn(`[pi-subagents:debug] ${context}:`, err);
+  if (isDebug()) console.warn(`[pi-subagents:debug] ${context}:`, err);
 }

package/src/index.ts

@@ -13,12 +13,13 @@
 import { join } from "node:path";
 import { defineTool, type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { AgentManager } from "./agent-manager.js";
-import { getAgentConversation, getDefaultMaxTurns, getGraceTurns, setDefaultMaxTurns, setGraceTurns, steerAgent } from "./agent-runner.js";
+import { getAgentConversation, normalizeMaxTurns, steerAgent } from "./agent-runner.js";
 import { getAgentConfig, getAvailableTypes, getDefaultAgentNames, getUserAgentNames, registerAgents, } from "./agent-types.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
 import { buildEventData, createNotificationSystem } from "./notification.js";
 import { createNotificationRenderer } from "./renderer.js";
+import { createSubagentRuntime } from "./runtime.js";
 import { publishSubagentsService, unpublishSubagentsService } from "./service.js";
 import { createSubagentsService } from "./service-adapter.js";
 import { applyAndEmitLoaded, saveAndEmitChanged } from "./settings.js";
@@ -29,7 +30,6 @@ import { createSteerTool } from "./tools/steer-tool.js";
 import { type NotificationDetails } from "./types.js";
 import { createAgentsMenuHandler } from "./ui/agent-menu.js";
 import {
-  type AgentActivity,
   AgentWidget,
   type UICtx,
 } from "./ui/agent-widget.js";
@@ -47,17 +47,17 @@ export default function (pi: ExtensionAPI) {
   // Initial load
   reloadCustomAgents();
 
-  // ---- Agent activity tracking ----
-  const agentActivity = new Map<string, AgentActivity>();
+  // ---- Runtime: all mutable extension state in one place ----
+  const runtime = createSubagentRuntime();
 
   // ---- Notification system ----
-  // Widget assigned after AgentManager construction; arrow closures capture by reference.
-  let widget: AgentWidget;
+  // runtime.widget is assigned after AgentManager construction; arrow closures
+  // capture `runtime` by reference so they always read the current value.
   const notifications = createNotificationSystem({
     sendMessage: (msg, opts) => pi.sendMessage(msg as any, opts as any),
-    agentActivity,
-    markFinished: (id) => widget.markFinished(id),
-    updateWidget: () => widget.update(),
+    agentActivity: runtime.agentActivity,
+    markFinished: (id) => runtime.widget!.markFinished(id),
+    updateWidget: () => runtime.widget!.update(),
   });
 
   // Background completion: emit lifecycle event and delegate to notification system
@@ -102,21 +102,21 @@ export default function (pi: ExtensionAPI) {
       tokensBefore: info.tokensBefore,
       compactionCount: record.compactionCount,
     });
-  });
+  },
+  () => ({ defaultMaxTurns: runtime.defaultMaxTurns, graceTurns: runtime.graceTurns }));
 
   // Typed service published via Symbol.for() for cross-extension access.
   // Consumers: const { getSubagentsService } = await import("@gotgenes/pi-subagents");
-  let currentCtx: { pi: unknown; ctx: unknown } | undefined;
   const service = createSubagentsService({
     manager,
     resolveModel,
-    getCtx: () => currentCtx,
-    getModelRegistry: () => (currentCtx?.ctx as { modelRegistry?: ModelRegistry } | undefined)?.modelRegistry,
+    getCtx: () => runtime.currentCtx,
+    getModelRegistry: () => (runtime.currentCtx?.ctx as { modelRegistry?: ModelRegistry } | undefined)?.modelRegistry,
   });
   publishSubagentsService(service);
 
   pi.on("session_start", async (_event, ctx) => {
-    currentCtx = { pi, ctx };
+    runtime.currentCtx = { pi, ctx };
     manager.clearCompleted();
   });
 
@@ -128,19 +128,19 @@ export default function (pi: ExtensionAPI) {
   // If the session is going down, there's nothing left to consume agent results.
   pi.on("session_shutdown", async () => {
     unpublishSubagentsService();
-    currentCtx = undefined;
+    runtime.currentCtx = undefined;
     manager.abortAll();
     notifications.dispose();
     manager.dispose();
   });
 
   // Live widget: show running agents above editor
-  widget = new AgentWidget(manager, agentActivity);
+  runtime.widget = new AgentWidget(manager, runtime.agentActivity);
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   pi.on("tool_execution_start", async (_event, ctx) => {
-    widget.setUICtx(ctx.ui as UICtx);
-    widget.onTurnStart();
+    runtime.widget!.setUICtx(ctx.ui as UICtx);
+    runtime.widget!.onTurnStart();
   });
 
   /** Build the full type list text dynamically from the unified registry. */
@@ -176,8 +176,8 @@ export default function (pi: ExtensionAPI) {
   applyAndEmitLoaded(
     {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
-      setDefaultMaxTurns,
-      setGraceTurns,
+      setDefaultMaxTurns: (n) => { runtime.defaultMaxTurns = normalizeMaxTurns(n); },
+      setGraceTurns: (n) => { runtime.graceTurns = Math.max(1, n); },
     },
     (event, payload) => pi.events.emit(event, payload),
   );
@@ -194,17 +194,18 @@ export default function (pi: ExtensionAPI) {
       listAgents: () => manager.listAgents(),
     },
     widget: {
-      setUICtx: (ctx) => widget.setUICtx(ctx as UICtx),
-      ensureTimer: () => widget.ensureTimer(),
-      update: () => widget.update(),
-      markFinished: (id) => widget.markFinished(id),
+      setUICtx: (ctx) => runtime.widget!.setUICtx(ctx as UICtx),
+      ensureTimer: () => runtime.widget!.ensureTimer(),
+      update: () => runtime.widget!.update(),
+      markFinished: (id) => runtime.widget!.markFinished(id),
     },
-    agentActivity,
+    agentActivity: runtime.agentActivity,
     emitEvent: (name, data) => pi.events.emit(name, data),
     reloadCustomAgents,
     typeListText,
     availableTypesText: getAvailableTypes().join(", "),
     agentDir: getAgentDir(),
+    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
   }) as any));
 
   // ---- get_subagent_result tool ----
@@ -234,7 +235,7 @@ export default function (pi: ExtensionAPI) {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
     },
     reloadCustomAgents,
-    agentActivity,
+    agentActivity: runtime.agentActivity,
     getModelLabel: (type, registry) => {
       const cfg = getAgentConfig(type);
       if (!cfg?.model) return 'inherit';
@@ -246,9 +247,17 @@ export default function (pi: ExtensionAPI) {
     },
     snapshotSettings: () => ({
       maxConcurrent: manager.getMaxConcurrent(),
-      defaultMaxTurns: getDefaultMaxTurns() ?? 0,
-      graceTurns: getGraceTurns(),
+      defaultMaxTurns: runtime.defaultMaxTurns ?? 0,
+      graceTurns: runtime.graceTurns,
     }),
+    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
+    getGraceTurns: () => runtime.graceTurns,
+    setDefaultMaxTurns: (n) => {
+      runtime.defaultMaxTurns = normalizeMaxTurns(n);
+    },
+    setGraceTurns: (n) => {
+      runtime.graceTurns = Math.max(1, n);
+    },
     saveSettings: (settings, successMsg) => saveAndEmitChanged(
       settings,
       successMsg,

package/src/runtime.ts

@@ -0,0 +1,62 @@
+/**
+ * runtime.ts — SubagentRuntime: composition root for all mutable extension state.
+ *
+ * Eliminates module-scope state in agent-runner.ts and closure-scoped state
+ * in index.ts by consolidating them into a single, testable object.
+ * Follows the same pattern as pi-permission-system's ExtensionRuntime.
+ */
+
+import type { AgentActivity, AgentWidget } from "./ui/agent-widget.js";
+
+/**
+ * Narrow config subset read by AgentManager when constructing RunOptions.
+ * Kept separate so callers can satisfy it without depending on the full runtime.
+ */
+export interface RunConfig {
+  readonly defaultMaxTurns: number | undefined;
+  readonly graceTurns: number;
+}
+
+/**
+ * All mutable state owned by the pi-subagents extension.
+ *
+ * Created once inside `piSubagentsExtension()` via `createSubagentRuntime()`.
+ * Tests construct a fresh runtime per test for full isolation.
+ */
+export interface SubagentRuntime {
+  // ── Execution config (was module-scope in agent-runner.ts) ──────────────
+  /** Default max turns for all agents. undefined = unlimited. */
+  defaultMaxTurns: number | undefined;
+  /** Additional turns allowed after the soft-limit steer message. */
+  graceTurns: number;
+
+  // ── Session state (was closure-scoped in index.ts) ───────────────────────
+  /** Active Pi session context — set on session_start, cleared on session_shutdown. */
+  currentCtx: { pi: unknown; ctx: unknown } | undefined;
+  /**
+   * Per-agent live activity state shared across the notification system,
+   * widget, and tool handlers. The Map itself is never replaced.
+   */
+  readonly agentActivity: Map<string, AgentActivity>;
+  /**
+   * Persistent widget reference. Null until constructed after AgentManager.
+   * Notification closures use `runtime.widget!` — safe because agents always
+   * complete after widget construction.
+   */
+  widget: AgentWidget | null;
+}
+
+/**
+ * Create a fully-initialized SubagentRuntime with default values.
+ *
+ * Call once at extension startup; pass the result to factories and handlers.
+ */
+export function createSubagentRuntime(): SubagentRuntime {
+  return {
+    defaultMaxTurns: undefined,
+    graceTurns: 5,
+    currentCtx: undefined,
+    agentActivity: new Map(),
+    widget: null,
+  };
+}