@soleri/core 9.3.0 → 9.4.0

package/src/planning/task-complexity-assessor.ts

@@ -0,0 +1,180 @@
+/**
+ * Task Complexity Assessor — pure function that classifies tasks as simple or complex.
+ *
+ * Used by the planning module to decide whether a decomposed GH issue
+ * needs a full plan or can be executed directly.
+ */
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface AssessmentInput {
+  /** User's task description. */
+  prompt: string;
+  /** Estimated number of files to touch. */
+  filesEstimated?: number;
+  /** GH issue body if available. */
+  parentIssueContext?: string;
+  /** Whether the approach is already described in a parent plan. */
+  hasParentPlan?: boolean;
+  /** Which domains are involved. */
+  domains?: string[];
+}
+
+export interface AssessmentSignal {
+  name: string;
+  weight: number;
+  triggered: boolean;
+  detail: string;
+}
+
+export interface AssessmentResult {
+  classification: 'simple' | 'complex';
+  /** 0-100 complexity score. Threshold at 40. */
+  score: number;
+  signals: AssessmentSignal[];
+  /** One-line explanation. */
+  reasoning: string;
+}
+
+// ─── Signal Detectors ───────────────────────────────────────────────
+
+const CROSS_CUTTING_PATTERNS = [
+  /\bauth(?:entication|orization)?\b/i,
+  /\bmigrat(?:e|ion|ing)\b/i,
+  /\brefactor(?:ing)?\s+across\b/i,
+  /\bcross[- ]cutting\b/i,
+];
+
+const NEW_DEPENDENCY_PATTERNS = [
+  /\badd\s+dep(?:endency|endencies)?\b/i,
+  /\binstall\b/i,
+  /\bnew\s+package\b/i,
+  /\bnpm\s+install\b/i,
+  /\badd\s+(?:a\s+)?(?:new\s+)?(?:npm\s+)?package\b/i,
+];
+
+const DESIGN_DECISION_PATTERNS = [
+  /\bhow\s+should\b/i,
+  /\bwhich\s+approach\b/i,
+  /\bdesign\s+decision\b/i,
+  /\barchitectur(?:e|al)\s+(?:decision|choice)\b/i,
+  /\btrade[- ]?off/i,
+];
+
+function detectFileCount(input: AssessmentInput): AssessmentSignal {
+  const files = input.filesEstimated ?? 0;
+  const triggered = files >= 3;
+  return {
+    name: 'file-count',
+    weight: 25,
+    triggered,
+    detail: triggered
+      ? `Estimated ${files} files (≥3 threshold)`
+      : files > 0
+        ? `Estimated ${files} file${files === 1 ? '' : 's'} (under threshold)`
+        : 'No file estimate provided',
+  };
+}
+
+function detectCrossCutting(input: AssessmentInput): AssessmentSignal {
+  const text = input.prompt;
+  const match = CROSS_CUTTING_PATTERNS.find((p) => p.test(text));
+  return {
+    name: 'cross-cutting-keywords',
+    weight: 20,
+    triggered: !!match,
+    detail: match
+      ? `Detected cross-cutting keyword: "${text.match(match)?.[0]}"`
+      : 'No cross-cutting keywords detected',
+  };
+}
+
+function detectNewDependencies(input: AssessmentInput): AssessmentSignal {
+  const text = input.prompt;
+  const match = NEW_DEPENDENCY_PATTERNS.find((p) => p.test(text));
+  return {
+    name: 'new-dependencies',
+    weight: 15,
+    triggered: !!match,
+    detail: match
+      ? `Detected dependency signal: "${text.match(match)?.[0]}"`
+      : 'No new dependency signals detected',
+  };
+}
+
+function detectDesignDecisions(input: AssessmentInput): AssessmentSignal {
+  const text = input.prompt;
+  const match = DESIGN_DECISION_PATTERNS.find((p) => p.test(text));
+  return {
+    name: 'design-decisions-needed',
+    weight: 20,
+    triggered: !!match,
+    detail: match
+      ? `Detected design decision signal: "${text.match(match)?.[0]}"`
+      : 'No design decision signals detected',
+  };
+}
+
+function detectApproachDescribed(input: AssessmentInput): AssessmentSignal {
+  const hasContext = !!(input.hasParentPlan || input.parentIssueContext?.trim());
+  return {
+    name: 'approach-already-described',
+    weight: -15,
+    triggered: hasContext,
+    detail: hasContext
+      ? 'Approach already described in parent plan or issue'
+      : 'No pre-existing approach context',
+  };
+}
+
+function detectMultiDomain(input: AssessmentInput): AssessmentSignal {
+  const domains = input.domains ?? [];
+  const triggered = domains.length >= 2;
+  return {
+    name: 'multi-domain',
+    weight: 5,
+    triggered,
+    detail: triggered
+      ? `Involves ${domains.length} domains: ${domains.join(', ')}`
+      : domains.length === 1
+        ? `Single domain: ${domains[0]}`
+        : 'No domains specified',
+  };
+}
+
+// ─── Assessor ───────────────────────────────────────────────────────
+
+const COMPLEXITY_THRESHOLD = 40;
+
+/**
+ * Assess task complexity from structured input.
+ *
+ * Returns a classification (`simple` | `complex`), a numeric score (0-100),
+ * the individual signals that contributed, and a one-line reasoning string.
+ *
+ * Pure function — no side effects, no DB, no MCP calls.
+ */
+export function assessTaskComplexity(input: AssessmentInput): AssessmentResult {
+  const signals: AssessmentSignal[] = [
+    detectFileCount(input),
+    detectCrossCutting(input),
+    detectNewDependencies(input),
+    detectDesignDecisions(input),
+    detectApproachDescribed(input),
+    detectMultiDomain(input),
+  ];
+
+  const rawScore = signals.reduce((sum, s) => sum + (s.triggered ? s.weight : 0), 0);
+
+  // Clamp to 0-100
+  const score = Math.max(0, Math.min(100, rawScore));
+  const classification = score >= COMPLEXITY_THRESHOLD ? 'complex' : 'simple';
+
+  const triggered = signals.filter((s) => s.triggered);
+  const reasoning =
+    triggered.length === 0
+      ? 'No complexity signals detected — treating as simple task'
+      : `${classification === 'complex' ? 'Complex' : 'Simple'}: ${triggered.map((s) => s.name).join(', ')} (score ${score})`;
+
+  return { classification, score, signals, reasoning };
+}

package/src/runtime/admin-ops.test.ts

@@ -35,6 +35,9 @@ function mockRuntime(): AgentRuntime {
     curator: {
       getStatus: vi.fn().mockReturnValue({ initialized: true }),
     },
+    packInstaller: {
+      list: vi.fn().mockReturnValue([]),
+    },
     contextHealth: {
       check: vi.fn().mockReturnValue({
         level: 'green',
@@ -67,8 +70,8 @@ describe('createAdminOps', () => {
     ops = createAdminOps(rt);
   });
 
-  it('returns 9 ops', () => {
-    expect(ops.length).toBe(9);
+  it('returns 11 ops', () => {
+    expect(ops.length).toBe(11);
   });
 
   // ─── admin_health ─────────────────────────────────────────────
@@ -98,6 +101,50 @@ describe('createAdminOps', () => {
       expect(llm.openai).toBe(true);
       expect(llm.anthropic).toBe(false);
     });
+
+    it('reports skills status', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const skills = result.skills as Record<string, unknown>;
+      expect(skills).toBeDefined();
+      expect(skills.count).toBe(0);
+      expect(skills.agent).toEqual([]);
+      expect(skills.packs).toEqual([]);
+    });
+
+    it('reports hooks status', async () => {
+      const op = findOp(ops, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const hooks = result.hooks as Record<string, unknown>;
+      expect(hooks).toBeDefined();
+      expect(hooks.count).toBe(0);
+      expect(hooks.packs).toEqual([]);
+    });
+
+    it('includes pack skills and hooks when packs are installed', async () => {
+      vi.mocked(rt.packInstaller.list).mockReturnValue([
+        {
+          id: 'test-pack',
+          manifest: {} as never,
+          directory: '/tmp/pack',
+          status: 'installed',
+          vaultEntries: 5,
+          skills: ['my-skill', 'another-skill'],
+          hooks: ['my-hook'],
+          facadesRegistered: false,
+          installedAt: Date.now(),
+        },
+      ]);
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'admin_health');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const skills = result.skills as Record<string, unknown>;
+      expect(skills.count).toBe(2);
+      expect(skills.packs).toEqual(['my-skill', 'another-skill']);
+      const hooks = result.hooks as Record<string, unknown>;
+      expect(hooks.count).toBe(1);
+      expect(hooks.packs).toEqual(['my-hook']);
+    });
   });
 
   // ─── context_health ───────────────────────────────────────────
@@ -133,6 +180,27 @@ describe('createAdminOps', () => {
       expect(grouped.vault).toContain('vault_search');
     });
 
+    it('returns routing hints in grouped mode', async () => {
+      const op = findOp(ops, 'admin_tool_list');
+      const allOps = [{ name: 'admin_health', description: 'Health check', auth: 'read' }];
+      const result = (await op.handler({ _allOps: allOps })) as Record<string, unknown>;
+      const routing = result.routing as Record<string, string>;
+      expect(routing).toBeDefined();
+      expect(typeof routing).toBe('object');
+      // Spot-check a few known intent signals
+      expect(routing['search knowledge']).toBe('vault.search_intelligent');
+      expect(routing['plan this']).toBe('plan.create_plan');
+      expect(routing['health check']).toBe('admin.admin_health');
+    });
+
+    it('returns routing hints in fallback mode', async () => {
+      const op = findOp(ops, 'admin_tool_list');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      const routing = result.routing as Record<string, string>;
+      expect(routing).toBeDefined();
+      expect(Object.keys(routing).length).toBeGreaterThan(0);
+    });
+
     it('returns verbose format when verbose=true', async () => {
       const op = findOp(ops, 'admin_tool_list');
       const allOps = [{ name: 'admin_health', description: 'Health check', auth: 'read' }];
@@ -206,6 +274,94 @@ describe('createAdminOps', () => {
     });
   });
 
+  // ─── operator_context_inspect ────────────────────────────────
+
+  describe('operator_context_inspect', () => {
+    it('returns full profile when store is available', async () => {
+      const mockContext = {
+        expertise: [
+          {
+            topic: 'TypeScript',
+            level: 'expert',
+            confidence: 0.9,
+            sessionCount: 5,
+            lastObserved: Date.now(),
+          },
+        ],
+        corrections: [],
+        interests: [
+          { tag: 'testing', confidence: 0.7, mentionCount: 3, lastMentioned: Date.now() },
+        ],
+        patterns: [],
+        sessionCount: 5,
+        lastUpdated: Date.now(),
+      };
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn().mockReturnValue(mockContext),
+        deleteItem: vi.fn(),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_inspect');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.available).toBe(true);
+      expect(result.expertise).toEqual(mockContext.expertise);
+      expect(result.interests).toEqual(mockContext.interests);
+    });
+
+    it('returns not-available when store is missing', async () => {
+      // Default mock runtime has no operatorContextStore
+      const op = findOp(ops, 'operator_context_inspect');
+      const result = (await op.handler({})) as Record<string, unknown>;
+      expect(result.available).toBe(false);
+      expect(result.message).toBe('Operator context not configured');
+    });
+  });
+
+  // ─── operator_context_delete ───────────────────────────────────
+
+  describe('operator_context_delete', () => {
+    it('removes an item successfully', async () => {
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn(),
+        deleteItem: vi.fn().mockReturnValue(true),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_delete');
+      const result = (await op.handler({ type: 'expertise', id: 'abc-123' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(true);
+      expect(result.type).toBe('expertise');
+      expect(result.id).toBe('abc-123');
+    });
+
+    it('returns false for missing item', async () => {
+      (rt as Record<string, unknown>).operatorContextStore = {
+        inspect: vi.fn(),
+        deleteItem: vi.fn().mockReturnValue(false),
+      };
+      const updatedOps = createAdminOps(rt);
+      const op = findOp(updatedOps, 'operator_context_delete');
+      const result = (await op.handler({ type: 'pattern', id: 'nonexistent' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(false);
+      expect(result.message).toBe('Item not found');
+    });
+
+    it('returns not-available when store is missing', async () => {
+      const op = findOp(ops, 'operator_context_delete');
+      const result = (await op.handler({ type: 'expertise', id: 'abc' })) as Record<
+        string,
+        unknown
+      >;
+      expect(result.deleted).toBe(false);
+      expect(result.message).toBe('Operator context not configured');
+    });
+  });
+
   // ─── admin_diagnostic ─────────────────────────────────────────
 
   describe('admin_diagnostic', () => {
@@ -218,7 +374,7 @@ describe('createAdminOps', () => {
       expect(result).toHaveProperty('checks');
       expect(result).toHaveProperty('summary');
       const checks = result.checks as Array<Record<string, string>>;
-      expect(checks.length).toBeGreaterThanOrEqual(5);
+      expect(checks.length).toBeGreaterThanOrEqual(8);
     });
 
     it('reports degraded when LLM unavailable', async () => {

package/src/runtime/admin-ops.ts

@@ -1,5 +1,5 @@
 /**
- * Admin / infrastructure operations — 8 ops for agent self-management.
+ * Admin / infrastructure operations — 11 ops for agent self-management.
  *
  * These ops let agents introspect their own health, configuration, and
  * runtime state. No new modules needed — uses existing runtime parts.
@@ -10,6 +10,8 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
+import { ENGINE_MODULE_MANIFEST } from '../engine/module-manifest.js';
+import { discoverSkills } from '../skills/sync-skills.js';
 
 /**
  * Resolve the @soleri/core package.json version.
@@ -41,13 +43,13 @@ function getCoreVersion(): string {
  * Groups: health (1–2), introspection (4), diagnostics (2), mutation (1).
  */
 export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, brainIntelligence, llmClient, curator } = runtime;
+  const { vault, brain, brainIntelligence, llmClient, curator, packInstaller } = runtime;
 
   return [
     // ─── Health ──────────────────────────────────────────────────────
     {
       name: 'admin_health',
-      description: 'Comprehensive agent health check — vault, LLM, brain status.',
+      description: 'Comprehensive agent health check — vault, LLM, brain, skills, hooks status.',
       auth: 'read',
       handler: async () => {
         const vaultStats = vault.stats();
@@ -55,6 +57,24 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
         const brainStats = brain.getStats();
         const curatorStatus = curator.getStatus();
 
+        // Skills: agent-level + pack-level
+        const agentDir = runtime.config.agentDir;
+        const agentSkillsDirs = agentDir ? [join(agentDir, 'skills')] : [];
+        const agentSkills = discoverSkills(agentSkillsDirs);
+        const packs = packInstaller.list();
+        const packSkills = packs.flatMap((p) => p.skills);
+        const allSkillNames = [...agentSkills.map((s) => s.name), ...packSkills];
+
+        // Hooks: pack-level
+        const packHooks = packs.flatMap((p) => p.hooks);
+
+        // Tier breakdown
+        const tierCounts = { default: 0, community: 0, premium: 0 };
+        for (const pk of packs) {
+          const t = (pk.manifest as { tier?: string })?.tier ?? 'community';
+          if (t in tierCounts) tierCounts[t as keyof typeof tierCounts]++;
+        }
+
         return {
           status: 'ok',
           vault: { entries: vaultStats.totalEntries, domains: Object.keys(vaultStats.byDomain) },
@@ -64,6 +84,16 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
             feedbackCount: brainStats.feedbackCount,
           },
           curator: { initialized: curatorStatus.initialized },
+          skills: {
+            count: allSkillNames.length,
+            agent: agentSkills.map((s) => s.name),
+            packs: packSkills,
+          },
+          hooks: {
+            count: packHooks.length,
+            packs: packHooks,
+          },
+          packTiers: tierCounts,
         };
       },
     },
@@ -113,6 +143,7 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           return {
             count: allOps.length,
             ops: grouped,
+            routing: buildRoutingHints(),
           };
         }
         // Fallback — just describe admin ops
@@ -130,6 +161,7 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
               'admin_diagnostic',
             ],
           },
+          routing: buildRoutingHints(),
         };
       },
     },
@@ -212,6 +244,39 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Operator Context ───────────────────────────────────────────
+    {
+      name: 'operator_context_inspect',
+      description:
+        'Inspect the full operator context profile — expertise, corrections, interests, patterns.',
+      auth: 'read',
+      handler: async () => {
+        const store = runtime.operatorContextStore;
+        if (!store) {
+          return { available: false, message: 'Operator context not configured' };
+        }
+        return { available: true, ...store.inspect() };
+      },
+    },
+    {
+      name: 'operator_context_delete',
+      description: 'Delete a specific item from the operator context profile.',
+      auth: 'write',
+      handler: async (params) => {
+        const store = runtime.operatorContextStore;
+        if (!store) {
+          return { deleted: false, message: 'Operator context not configured' };
+        }
+        const type = params.type as string;
+        const id = params.id as string;
+        const deleted = store.deleteItem(type as Parameters<typeof store.deleteItem>[0], id);
+        if (deleted) {
+          return { deleted: true, type, id };
+        }
+        return { deleted: false, message: 'Item not found' };
+      },
+    },
+
     // ─── Diagnostics ─────────────────────────────────────────────────
     {
       name: 'admin_diagnostic',
@@ -298,6 +363,45 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           });
         }
 
+        // 7. Skills
+        try {
+          const agentDir = runtime.config.agentDir;
+          const skillsDirs = agentDir ? [join(agentDir, 'skills')] : [];
+          const agentSkills = discoverSkills(skillsDirs);
+          const installedPacks = packInstaller.list();
+          const packSkillCount = installedPacks.reduce((sum, p) => sum + p.skills.length, 0);
+          const totalSkills = agentSkills.length + packSkillCount;
+          const skillStatus = totalSkills > 0 ? 'ok' : agentDir ? 'warn' : 'ok';
+          checks.push({
+            name: 'skills',
+            status: skillStatus,
+            detail: `${totalSkills} skills (${agentSkills.length} agent, ${packSkillCount} pack)`,
+          });
+        } catch (err) {
+          checks.push({
+            name: 'skills',
+            status: 'error',
+            detail: err instanceof Error ? err.message : String(err),
+          });
+        }
+
+        // 8. Hooks
+        try {
+          const installedPacks = packInstaller.list();
+          const packHookCount = installedPacks.reduce((sum, p) => sum + p.hooks.length, 0);
+          checks.push({
+            name: 'hooks',
+            status: 'ok',
+            detail: `${packHookCount} hooks from ${installedPacks.length} packs`,
+          });
+        } catch (err) {
+          checks.push({
+            name: 'hooks',
+            status: 'error',
+            detail: err instanceof Error ? err.message : String(err),
+          });
+        }
+
         const errorCount = checks.filter((c) => c.status === 'error').length;
         const warnCount = checks.filter((c) => c.status === 'warn').length;
         const overall = errorCount > 0 ? 'unhealthy' : warnCount > 0 ? 'degraded' : 'healthy';
@@ -321,6 +425,22 @@ function formatBytes(bytes: number): string {
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
+/**
+ * Build a flat routing map from ENGINE_MODULE_MANIFEST intentSignals.
+ * Keys are natural-language phrases, values are `{suffix}.{op}` paths.
+ */
+function buildRoutingHints(): Record<string, string> {
+  const routing: Record<string, string> = {};
+  for (const mod of ENGINE_MODULE_MANIFEST) {
+    if (mod.intentSignals) {
+      for (const [phrase, op] of Object.entries(mod.intentSignals)) {
+        routing[phrase] = `${mod.suffix}.${op}`;
+      }
+    }
+  }
+  return routing;
+}
+
 function formatUptime(seconds: number): string {
   if (seconds < 60) return `${seconds}s`;
   const minutes = Math.floor(seconds / 60);

package/src/runtime/admin-setup-ops.ts

@@ -99,7 +99,7 @@ function discoverHookifyFiles(dir: string): Array<{ name: string; path: string }
 // ─── Settings.json Hook Merging ───────────────────────────────────────
 
 interface SettingsHook {
-  type: 'prompt' | 'agent';
+  type: 'prompt' | 'agent' | 'command';
   prompt?: string;
   command?: string;
   timeout?: number;
@@ -110,6 +110,17 @@ interface SettingsHookGroup {
   hooks: SettingsHook[];
 }
 
+/**
+ * Build a shell command that checks if the agent's MCP server is configured
+ * in the current project's .mcp.json before emitting an instruction.
+ * This ensures hooks are globally safe — they no-op in projects without the agent.
+ */
+function buildConditionalHookCommand(agentId: string, instruction: string): string {
+  // Escape single quotes in instruction for safe shell embedding
+  const escaped = instruction.replace(/'/g, "'\\''");
+  return `root=$(git rev-parse --show-toplevel 2>/dev/null || echo "."); if grep -q '"${agentId}"' "$root/.mcp.json" 2>/dev/null; then echo '${escaped}'; fi`;
+}
+
 /** Default lifecycle hooks for any Soleri agent */
 function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookGroup[]> {
   const marker = `mcp__${agentId}__${agentId}_`;
@@ -120,9 +131,12 @@ function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookG
         matcher: '',
         hooks: [
           {
-            type: 'prompt',
-            prompt: `Call ${marker}admin op:admin_health to verify agent is ready. Do not show the result unless there are errors.`,
-            timeout: 15000,
+            type: 'command',
+            command: buildConditionalHookCommand(
+              agentId,
+              `Call ${marker}admin op:admin_health to verify agent is ready. Do not show the result unless there are errors.`,
+            ),
+            timeout: 5000,
           },
         ],
       },
@@ -132,9 +146,12 @@ function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookG
         matcher: '',
         hooks: [
           {
-            type: 'agent',
-            prompt: `Call ${marker}memory op:session_capture with a brief summary of the current session before context is compacted.`,
-            timeout: 30000,
+            type: 'command',
+            command: buildConditionalHookCommand(
+              agentId,
+              `First, call ${marker}plan op:plan_close_stale params:{ olderThanMs: 0 } to auto-close any plans still in non-terminal states. Then call ${marker}memory op:session_capture with a brief summary of the current session before context is compacted. Include any auto-closed plan IDs in the summary.`,
+            ),
+            timeout: 10000,
           },
         ],
       },
@@ -144,9 +161,12 @@ function getDefaultLifecycleHooks(agentId: string): Record<string, SettingsHookG
         matcher: '',
         hooks: [
           {
-            type: 'agent',
-            prompt: `Call ${marker}memory op:session_capture with a structured summary of what was accomplished, then check ${marker}loop op:loop_status — if a loop is active, remind the user.`,
-            timeout: 30000,
+            type: 'command',
+            command: buildConditionalHookCommand(
+              agentId,
+              `First, call ${marker}plan op:plan_close_stale params:{ olderThanMs: 0 } to auto-close any plans still in non-terminal states. Then call ${marker}memory op:session_capture with a structured summary of what was accomplished, including any auto-closed plan IDs. Finally check ${marker}loop op:loop_status — if a loop is active, remind the user.`,
+            ),
+            timeout: 10000,
           },
         ],
       },