@soleri/core 9.3.0 → 9.4.0

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

@@ -37,6 +37,19 @@ function createMockRuntime(): AgentRuntime {
         entry: { id: 'captured-1' },
       })),
       intelligentSearch: vi.fn(async () => [{ id: 'r1', title: 'Result 1', score: 0.8 }]),
+      scanSearch: vi.fn(async () => [
+        {
+          id: 'r1',
+          title: 'Result 1',
+          score: 0.8,
+          snippet: 'Short desc...',
+          tokenEstimate: 50,
+          type: 'pattern',
+          domain: 'test',
+          severity: 'suggestion',
+          tags: ['test'],
+        },
+      ]),
       recordFeedback: vi.fn(),
     },
     governance: {
@@ -365,6 +378,77 @@ describe('createCaptureOps', () => {
       })) as Array<Record<string, unknown>>;
       expect((result[0].score as number) >= (result[1].score as number)).toBe(true);
     });
+
+    it('scan mode calls brain.scanSearch instead of intelligentSearch', async () => {
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'test patterns',
+        mode: 'scan',
+      })) as Array<Record<string, unknown>>;
+      expect(runtime.brain.scanSearch).toHaveBeenCalledWith(
+        'test patterns',
+        expect.objectContaining({ limit: 10 }),
+      );
+      expect(runtime.brain.intelligentSearch).not.toHaveBeenCalled();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result[0].source).toBe('vault');
+      expect(result[0].snippet).toBeDefined();
+    });
+
+    it('scan mode defaults limit to 10', async () => {
+      await findOp(ops, 'search_intelligent').handler({
+        query: 'test',
+        mode: 'scan',
+      });
+      expect(runtime.brain.scanSearch).toHaveBeenCalledWith(
+        'test',
+        expect.objectContaining({ limit: 10 }),
+      );
+    });
+
+    it('full mode (default) still uses intelligentSearch with limit 20', async () => {
+      await findOp(ops, 'search_intelligent').handler({
+        query: 'test',
+      });
+      expect(runtime.brain.intelligentSearch).toHaveBeenCalledWith(
+        'test',
+        expect.objectContaining({ limit: 20 }),
+      );
+      expect(runtime.brain.scanSearch).not.toHaveBeenCalled();
+    });
+
+    it('scan mode with includeMemories returns lightweight memory results', async () => {
+      vi.mocked(runtime.vault.searchMemories).mockReturnValue([
+        {
+          id: 'm1',
+          summary:
+            'A long memory summary that should be truncated to 120 chars for scan mode lightweight results test',
+          context: 'Auth context',
+        },
+      ] as unknown);
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'auth',
+        mode: 'scan',
+        includeMemories: true,
+      })) as Array<Record<string, unknown>>;
+      const memResult = result.find((r) => r.source === 'memory');
+      expect(memResult).toBeDefined();
+      expect(memResult!.id).toBe('m1');
+      expect(memResult!.snippet).toBeDefined();
+      expect(typeof memResult!.snippet).toBe('string');
+      // Should NOT have full memory fields
+      expect(memResult!.filesModified).toBeUndefined();
+      expect(memResult!.toolsUsed).toBeUndefined();
+    });
+
+    it('scan mode handles search failure gracefully', async () => {
+      vi.mocked(runtime.brain.scanSearch).mockRejectedValue(new Error('Scan failed'));
+      const result = (await findOp(ops, 'search_intelligent').handler({
+        query: 'anything',
+        mode: 'scan',
+      })) as Array<Record<string, unknown>>;
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(0);
+    });
   });
 
   describe('search_feedback', () => {

package/src/runtime/capture-ops.ts

@@ -484,28 +484,42 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
     {
       name: 'search_intelligent',
       description:
-        'Project-scoped intelligent search combining vault FTS, brain TF-IDF ranking, and optional memory search.',
+        'Project-scoped intelligent search combining vault FTS, brain TF-IDF ranking, and optional memory search. mode:"scan" returns lightweight results (titles + scores + snippets) for two-pass retrieval. mode:"full" (default) returns complete entries.',
       auth: 'read',
       schema: z.object({
         query: z.string(),
         projectPath: z.string().optional(),
         domain: z.string().optional(),
         type: z.string().optional(),
-        limit: z.number().optional().default(20),
+        limit: z.number().optional(),
         includeMemories: z.boolean().optional().default(false),
+        mode: z
+          .enum(['full', 'scan'])
+          .optional()
+          .default('full')
+          .describe(
+            'full = complete entries with scoring breakdowns, scan = lightweight titles + scores for two-pass retrieval',
+          ),
       }),
       handler: async (params) => {
         const query = params.query as string;
         const domain = params.domain as string | undefined;
         const type = params.type as string | undefined;
-        const limit = (params.limit as number | undefined) ?? 20;
+        const mode = (params.mode as string | undefined) ?? 'full';
+        const isScan = mode === 'scan';
+        const limit = (params.limit as number | undefined) ?? (isScan ? 10 : 20);
         const includeMemories = (params.includeMemories as boolean | undefined) ?? false;
 
-        // Search vault via brain's intelligent search (TF-IDF ranked)
+        // Search vault — scan mode returns lightweight results, full returns complete entries
         let vaultResults: Array<{ source: string; [key: string]: unknown }> = [];
         try {
-          const ranked = await brain.intelligentSearch(query, { domain, type, limit });
-          vaultResults = ranked.map((r) => ({ ...r, source: 'vault' }));
+          if (isScan) {
+            const scanned = await brain.scanSearch(query, { domain, type, limit });
+            vaultResults = scanned.map((r) => ({ ...r, source: 'vault' }));
+          } else {
+            const ranked = await brain.intelligentSearch(query, { domain, type, limit });
+            vaultResults = ranked.map((r) => ({ ...r, source: 'vault' }));
+          }
         } catch {
           // Graceful degradation — return empty vault results
         }
@@ -515,7 +529,21 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
         if (includeMemories) {
           try {
             const memories = vault.searchMemories(query, { limit });
-            memoryResults = memories.map((m) => ({ ...m, source: 'memory', score: 0.5 }));
+            if (isScan) {
+              // Lightweight memory results for scan mode
+              memoryResults = memories.map((m) => {
+                const desc = m.summary ?? '';
+                return {
+                  id: m.id,
+                  title: m.context ?? '',
+                  snippet: desc.slice(0, 120) + (desc.length > 120 ? '...' : ''),
+                  score: 0.5,
+                  source: 'memory',
+                };
+              });
+            } else {
+              memoryResults = memories.map((m) => ({ ...m, source: 'memory', score: 0.5 }));
+            }
           } catch {
             // Graceful degradation — return empty memory results
           }

package/src/runtime/facades/admin-facade.test.ts

@@ -84,7 +84,7 @@ function mockRuntime(): AgentRuntime {
     pluginRegistry: {
       get: vi.fn(),
     },
-    packInstaller: {},
+    packInstaller: { list: vi.fn(() => []) },
     createdAt: Date.now() - 60000,
     persona: { name: 'TestAgent' },
   } as unknown as AgentRuntime;

package/src/runtime/facades/brain-facade.ts

@@ -466,13 +466,16 @@ export function createBrainFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'radar_dismiss',
-      description: 'Dismiss a pending radar candidate — marks it as not worth capturing.',
+      description:
+        'Dismiss one or more pending radar candidates — marks them as not worth capturing. Accepts a single ID or an array.',
       auth: 'write',
       schema: z.object({
-        candidateId: z.number().describe('Radar candidate ID to dismiss'),
+        candidateId: z
+          .union([z.number(), z.array(z.number())])
+          .describe('Radar candidate ID(s) to dismiss — single number or array'),
       }),
       handler: async (params) => {
-        return learningRadar.dismiss(params.candidateId as number);
+        return learningRadar.dismiss(params.candidateId as number | number[]);
       },
     },
     {

package/src/runtime/facades/control-facade.ts

@@ -118,11 +118,19 @@ export function createControlFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         mode: z
           .string()
           .describe(
-            'The operational mode to switch to. Valid modes: BUILD-MODE, FIX-MODE, VALIDATE-MODE, DESIGN-MODE, IMPROVE-MODE, DELIVER-MODE, EXPLORE-MODE, PLAN-MODE, REVIEW-MODE, GENERAL-MODE. Use "reset" to return to GENERAL-MODE.',
+            'The operational mode to switch to. Valid modes: BUILD-MODE, FIX-MODE, VALIDATE-MODE, DESIGN-MODE, IMPROVE-MODE, DELIVER-MODE, EXPLORE-MODE, PLAN-MODE, REVIEW-MODE, GENERAL-MODE, YOLO-MODE. Use "reset" to return to GENERAL-MODE.',
+          ),
+        hookPackInstalled: z
+          .boolean()
+          .optional()
+          .describe(
+            'Whether the yolo-safety hook pack is installed. Required for YOLO-MODE activation. The CLI layer should check for the hook pack before calling morph.',
           ),
       }),
       handler: async (params) => {
-        return intentRouter.morph(params.mode as OperationalMode);
+        return intentRouter.morph(params.mode as OperationalMode, {
+          hookPackInstalled: params.hookPackInstalled as boolean | undefined,
+        });
       },
     },
     {

package/src/runtime/facades/curator-facade.ts

@@ -36,6 +36,24 @@ export function createCuratorFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         );
       },
     },
+    {
+      name: 'curator_dismiss_duplicate',
+      description:
+        'Dismiss a flagged duplicate pair — marks two entries as reviewed and intentionally distinct. They will no longer appear in curator_detect_duplicates results.',
+      auth: 'write',
+      schema: z.object({
+        entryIdA: z.string().describe('First entry ID'),
+        entryIdB: z.string().describe('Second entry ID'),
+        reason: z.string().optional().describe('Why these are not duplicates'),
+      }),
+      handler: async (params) => {
+        return curator.dismissDuplicate(
+          params.entryIdA as string,
+          params.entryIdB as string,
+          params.reason as string | undefined,
+        );
+      },
+    },
     {
       name: 'curator_contradictions',
       description: 'List or detect contradictions between patterns and anti-patterns.',

package/src/runtime/facades/memory-facade.test.ts

@@ -67,7 +67,8 @@ describe('memory-facade', () => {
   it('memory_search returns empty for no matches', async () => {
     const result = await executeOp(ops, 'memory_search', { query: 'nonexistent' });
     expect(result.success).toBe(true);
-    expect((result.data as Record<string, unknown>).total).toBe(0);
+    const data = result.data as unknown[];
+    expect(data.length).toBe(0);
   });
 
   it('memory_search finds captured memories', async () => {
@@ -79,7 +80,8 @@ describe('memory-facade', () => {
     });
     const result = await executeOp(ops, 'memory_search', { query: 'token migration' });
     expect(result.success).toBe(true);
-    expect((result.data as Record<string, unknown>).total).toBeGreaterThanOrEqual(1);
+    const data = result.data as unknown[];
+    expect(data.length).toBeGreaterThanOrEqual(1);
   });
 
   it('memory_search returns summaries by default', async () => {
@@ -91,9 +93,9 @@ describe('memory-facade', () => {
     });
     const result = await executeOp(ops, 'memory_search', { query: 'short summary' });
     expect(result.success).toBe(true);
-    const data = result.data as { results: Array<{ summary: string }> };
-    expect(data.results[0]).toHaveProperty('summary');
-    expect(data.results[0]).not.toHaveProperty('context');
+    const data = result.data as Array<{ summary: string }>;
+    expect(data[0]).toHaveProperty('summary');
+    expect(data[0]).not.toHaveProperty('context');
   });
 
   it('memory_search returns full objects with verbose:true', async () => {
@@ -105,8 +107,8 @@ describe('memory-facade', () => {
     });
     const result = await executeOp(ops, 'memory_search', { query: 'verbose test', verbose: true });
     expect(result.success).toBe(true);
-    const data = result.data as { results: Array<Record<string, unknown>> };
-    expect(data.results[0]).toHaveProperty('context');
+    const data = result.data as Array<Record<string, unknown>>;
+    expect(data[0]).toHaveProperty('context');
   });
 
   // ─── memory_list ───────────────────────────────────────────────
@@ -120,9 +122,9 @@ describe('memory-facade', () => {
     });
     const result = await executeOp(ops, 'memory_list', {});
     expect(result.success).toBe(true);
-    const data = result.data as { entries: unknown[]; total: number };
-    expect(data.total).toBeGreaterThanOrEqual(1);
-    expect(data.entries.length).toBeGreaterThanOrEqual(1);
+    const data = result.data as { memories: unknown[]; stats: { total: number } };
+    expect(data.stats.total).toBeGreaterThanOrEqual(1);
+    expect(data.memories.length).toBeGreaterThanOrEqual(1);
   });
 
   it('memory_list filters by type', async () => {
@@ -140,8 +142,8 @@ describe('memory-facade', () => {
     });
     const result = await executeOp(ops, 'memory_list', { type: 'lesson' });
     expect(result.success).toBe(true);
-    const data = result.data as { entries: unknown[]; total: number };
-    expect(data.entries.length).toBe(1);
+    const data = result.data as { memories: unknown[]; stats: Record<string, unknown> };
+    expect(data.memories.length).toBe(1);
   });
 
   it('memory_list verbose returns full objects', async () => {

package/src/runtime/facades/memory-facade.ts

@@ -45,17 +45,15 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           limit: (params.limit as number) ?? 10,
         });
         if (params.verbose) {
-          return { results: memories, total: memories.length };
+          return memories;
         }
-        return {
-          results: memories.map((m) => ({
-            id: m.id,
-            summary: truncateSummary(m.summary || m.context),
-            score: null,
-            project: m.projectPath,
-          })),
-          total: memories.length,
-        };
+        return memories.map((m) => ({
+          id: m.id,
+          type: m.type,
+          summary: truncateSummary(m.summary || m.context),
+          score: null,
+          project: m.projectPath,
+        }));
       },
     },
     {
@@ -117,13 +115,13 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           return { memories, stats };
         }
         return {
-          entries: memories.map((m) => ({
+          memories: memories.map((m) => ({
             id: m.id,
             summary: truncateSummary(m.summary || m.context),
             project: m.projectPath,
             createdAt: m.createdAt,
           })),
-          total: stats.total,
+          stats,
         };
       },
     },

package/src/runtime/facades/orchestrate-facade.ts

@@ -25,7 +25,9 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
         name: z.string().optional().describe('Project display name (derived from path if omitted)'),
       }),
       handler: async (params) => {
-        const { resolve } = await import('node:path');
+        const { resolve, join } = await import('node:path');
+        const { homedir } = await import('node:os');
+        const { existsSync, readdirSync, statSync } = await import('node:fs');
         const projectPath = resolve((params.projectPath as string) ?? '.');
         const project = vault.registerProject(projectPath, params.name as string | undefined);
         // Also track in project registry for cross-project features
@@ -40,6 +42,35 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
         const proposalStats = governance.getProposalStats(projectPath);
         const quotaStatus = governance.getQuotaStatus(projectPath);
 
+        // Check for stale staging backups (lightweight — stat only, no tree walk)
+        let stagingWarning: { count: number; message: string } | undefined;
+        try {
+          const stagingRoot = join(homedir(), '.soleri', 'staging');
+          if (existsSync(stagingRoot)) {
+            const maxAgeMs = 7 * 24 * 60 * 60 * 1000; // 7 days
+            const cutoff = Date.now() - maxAgeMs;
+            const dirs = readdirSync(stagingRoot, { withFileTypes: true });
+            let staleCount = 0;
+            for (const dir of dirs) {
+              if (!dir.isDirectory()) continue;
+              try {
+                const st = statSync(join(stagingRoot, dir.name));
+                if (st.mtimeMs < cutoff) staleCount++;
+              } catch {
+                // skip unreadable entries
+              }
+            }
+            if (staleCount > 0) {
+              stagingWarning = {
+                count: staleCount,
+                message: `${staleCount} staging backup(s) older than 7 days. Run: soleri staging cleanup --yes`,
+              };
+            }
+          }
+        } catch {
+          // Non-critical — don't fail session start over staging check
+        }
+
         return {
           project,
           is_new: isNew,
@@ -56,6 +87,7 @@ export function createOrchestrateFacadeOps(runtime: AgentRuntime): OpDefinition[
             isQuotaWarning: quotaStatus.isWarning,
             expiredThisSession: expired,
           },
+          ...(stagingWarning ? { stagingWarning } : {}),
         };
       },
     },

package/src/runtime/facades/plan-facade.test.ts

@@ -239,6 +239,66 @@ describe('plan-facade', () => {
     expect(data.iterated).toBe(true);
   });
 
+  it('plan_iterate with decisions persists them', async () => {
+    const createResult = await executeOp(ops, 'create_plan', {
+      objective: 'Decisions test',
+      scope: 'test',
+    });
+    const planId = ((createResult.data as Record<string, unknown>).plan as Record<string, unknown>)
+      .id as string;
+
+    const result = await executeOp(ops, 'plan_iterate', {
+      planId,
+      decisions: [{ decision: 'Use FTS5', rationale: 'Performance' }],
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as { iterated: boolean; plan: Record<string, unknown> };
+    expect(data.iterated).toBe(true);
+    const decisions = data.plan.decisions as Array<Record<string, string>>;
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].decision).toBe('Use FTS5');
+  });
+
+  it('plan_iterate with alternatives persists them', async () => {
+    const createResult = await executeOp(ops, 'create_plan', {
+      objective: 'Alternatives test',
+      scope: 'test',
+    });
+    const planId = ((createResult.data as Record<string, unknown>).plan as Record<string, unknown>)
+      .id as string;
+
+    const result = await executeOp(ops, 'plan_iterate', {
+      planId,
+      alternatives: [
+        { approach: 'Alt A', pros: ['fast'], cons: ['fragile'], rejected_reason: 'Too risky' },
+        { approach: 'Alt B', pros: ['safe'], cons: ['slow'], rejected_reason: 'Too slow' },
+      ],
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as { iterated: boolean; plan: Record<string, unknown> };
+    expect(data.iterated).toBe(true);
+    const alternatives = data.plan.alternatives as Array<Record<string, unknown>>;
+    expect(alternatives).toHaveLength(2);
+    expect(alternatives[0].approach).toBe('Alt A');
+  });
+
+  it('plan_iterate with no effective changes returns iterated: false', async () => {
+    const createResult = await executeOp(ops, 'create_plan', {
+      objective: 'No-op test',
+      scope: 'test',
+    });
+    const planId = ((createResult.data as Record<string, unknown>).plan as Record<string, unknown>)
+      .id as string;
+
+    const result = await executeOp(ops, 'plan_iterate', {
+      planId,
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as { iterated: boolean; reason?: string };
+    expect(data.iterated).toBe(false);
+    expect(data.reason).toBe('no changes detected');
+  });
+
   // ─── plan_stats ────────────────────────────────────────────────
 
   it('plan_stats returns statistics', async () => {
@@ -280,4 +340,157 @@ describe('plan-facade', () => {
     expect(result.success).toBe(true);
     expect((result.data as Record<string, unknown>).error).toContain('not found');
   });
+
+  // ─── create_plan vault enrichment ─────────────────────────────
+
+  it('create_plan enriches decisions with vault patterns when matches exist', async () => {
+    // Seed vault with a relevant entry
+    vault.add({
+      title: 'SQLite FTS5 search pattern',
+      description: 'Use FTS5 with porter tokenizer for all text search',
+      content: 'Use FTS5 with porter tokenizer for all text search',
+      type: 'pattern',
+      domain: 'architecture',
+      severity: 'suggestion',
+      tags: ['sqlite', 'search'],
+    });
+
+    const result = await executeOp(ops, 'create_plan', {
+      objective: 'Implement text search with SQLite FTS5',
+      scope: 'packages/core/src/vault',
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as {
+      created: boolean;
+      plan: Record<string, unknown>;
+      vaultEntryIds: string[];
+    };
+    expect(data.created).toBe(true);
+    expect(data.vaultEntryIds.length).toBeGreaterThan(0);
+    // Decisions should contain vault pattern references with entryId markers
+    const decisions = data.plan.decisions as string[];
+    const vaultDecisions = decisions.filter((d) => d.startsWith('Vault pattern:'));
+    expect(vaultDecisions.length).toBeGreaterThan(0);
+    // Each vault decision should have an [entryId:...] marker for brain feedback
+    for (const vd of vaultDecisions) {
+      expect(vd).toMatch(/\[entryId:[^\]]+\]/);
+    }
+  });
+
+  it('create_plan works without vault matches (empty vault)', async () => {
+    // Fresh vault, no entries
+    const result = await executeOp(ops, 'create_plan', {
+      objective: 'Something completely unrelated xyz123',
+      scope: 'test',
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as {
+      created: boolean;
+      vaultEntryIds: string[];
+    };
+    expect(data.created).toBe(true);
+    expect(data.vaultEntryIds).toEqual([]);
+  });
+
+  it('create_plan preserves user decisions alongside vault enrichment', async () => {
+    vault.add({
+      title: 'Testing pattern',
+      description: 'Always write tests before implementation',
+      content: 'Always write tests before implementation',
+      type: 'pattern',
+      domain: 'testing',
+      severity: 'suggestion',
+      tags: ['tdd'],
+    });
+
+    const result = await executeOp(ops, 'create_plan', {
+      objective: 'Add testing patterns to the project',
+      scope: 'packages/core',
+      decisions: ['Use vitest as test runner'],
+    });
+    expect(result.success).toBe(true);
+    const data = result.data as { plan: Record<string, unknown>; vaultEntryIds: string[] };
+    const decisions = data.plan.decisions as string[];
+    // User decision preserved
+    expect(decisions).toContain('Use vitest as test runner');
+    // Vault enrichment added
+    if (data.vaultEntryIds.length > 0) {
+      const vaultDecisions = decisions.filter((d) => d.startsWith('Vault pattern:'));
+      expect(vaultDecisions.length).toBeGreaterThan(0);
+    }
+  });
+
+  // ─── plan_close_stale ─────────────────────────────────────────
+
+  it('plan_close_stale op is registered', () => {
+    expect([...ops.keys()]).toContain('plan_close_stale');
+  });
+
+  it('plan_close_stale returns no plans when none are stale', async () => {
+    const result = await executeOp(ops, 'plan_close_stale', {});
+    expect(result.success).toBe(true);
+    const data = result.data as { closed: number; plans: unknown[] };
+    expect(data.closed).toBe(0);
+    expect(data.plans).toHaveLength(0);
+  });
+
+  it('plan_close_stale with olderThanMs: 0 closes all non-terminal plans', async () => {
+    // Create a draft plan
+    await executeOp(ops, 'create_plan', { objective: 'Stale test', scope: 'test' });
+
+    // Close immediately (olderThanMs: 0 means close everything)
+    const result = await executeOp(ops, 'plan_close_stale', { olderThanMs: 0 });
+    expect(result.success).toBe(true);
+    const data = result.data as { closed: number; plans: Array<{ id: string; reason: string }> };
+    expect(data.closed).toBeGreaterThanOrEqual(1);
+    expect(data.plans[0].reason).toContain('ttl-expired');
+  });
+
+  // ─── Planner.closeStale() ─────────────────────────────────────
+
+  it('closeStale closes draft plans older than TTL', () => {
+    const runtime = makeRuntime(vault);
+    const planner = runtime.planner;
+
+    // Create a plan — it's immediately a draft
+    planner.create({ objective: 'Old draft', scope: 'test' });
+
+    // Close with olderThanMs: 0 to force-close regardless of age
+    const result = planner.closeStale(0);
+    expect(result.closedPlans.length).toBeGreaterThanOrEqual(1);
+    expect(result.closedPlans[0].previousStatus).toBe('draft');
+    expect(result.closedPlans[0].reason).toContain('ttl-expired');
+  });
+
+  it('closeStale does not close completed plans', () => {
+    const runtime = makeRuntime(vault);
+    const planner = runtime.planner;
+
+    // Create and complete a plan
+    const plan = planner.create({
+      objective: 'Completed plan',
+      scope: 'test',
+      decisions: ['d1', 'd2'],
+      tasks: [{ title: 'T1', description: 'd1' }],
+    });
+    planner.approve(plan.id);
+    planner.startExecution(plan.id);
+    planner.complete(plan.id);
+
+    // closeStale should not touch it
+    const result = planner.closeStale(0);
+    expect(result.closedPlans.filter((p) => p.id === plan.id)).toHaveLength(0);
+  });
+
+  it('closeStale respects default TTL — does not close fresh drafts', () => {
+    const runtime = makeRuntime(vault);
+    const planner = runtime.planner;
+
+    // Create a fresh plan
+    planner.create({ objective: 'Fresh draft', scope: 'test' });
+
+    // Close with default TTL (30 min) — fresh plan should NOT be closed
+    const result = planner.closeStale();
+    expect(result.closedPlans).toHaveLength(0);
+  });
 });