@soleri/core 9.3.1 → 9.5.0

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

@@ -30,6 +30,13 @@ function mockRuntime(): AgentRuntime {
       start: vi.fn(),
       stop: vi.fn(),
     },
+    shutdownRegistry: {
+      register: vi.fn(),
+      closeAll: vi.fn(),
+      closeAllSync: vi.fn(),
+      size: 0,
+      isClosed: false,
+    },
   } as unknown as AgentRuntime;
 }
 

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,
         };
       },
     },
@@ -197,6 +195,193 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Handoff ────────────────────────────────────────────────
+    {
+      name: 'handoff_generate',
+      description:
+        'Generate a structured handoff document for context transitions. ' +
+        'Pulls from active plan (if any) and recent session memories to produce ' +
+        'a markdown document that can bootstrap a new context window. ' +
+        'Ephemeral — NOT persisted to vault.',
+      auth: 'read',
+      schema: z.object({
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project path for filtering memories'),
+        sessionLimit: z
+          .number()
+          .optional()
+          .default(3)
+          .describe('Number of recent session memories to include'),
+      }),
+      handler: async (params) => {
+        const { planner } = runtime;
+        const projectPath = params.projectPath as string;
+        const sessionLimit = (params.sessionLimit as number) ?? 3;
+
+        const sections: string[] = [];
+        const now = new Date().toISOString();
+
+        sections.push('# Handoff Document');
+        sections.push('');
+        sections.push(`Generated: ${now}`);
+        sections.push('');
+
+        // ─── Active Plan Context ───────────────────────────
+        const activePlans = planner.getActive();
+        if (activePlans.length > 0) {
+          const plan = activePlans[0]; // Most relevant active plan
+          sections.push('## Active Plan');
+          sections.push('');
+          sections.push(`| Field | Value |`);
+          sections.push(`|-------|-------|`);
+          sections.push(`| **Plan ID** | ${plan.id} |`);
+          sections.push(`| **Objective** | ${plan.objective} |`);
+          sections.push(`| **Status** | ${plan.status} |`);
+          sections.push(`| **Scope** | ${plan.scope} |`);
+          sections.push('');
+
+          // Decisions
+          if (plan.decisions.length > 0) {
+            sections.push('### Decisions');
+            sections.push('');
+            for (const d of plan.decisions) {
+              if (typeof d === 'string') {
+                sections.push(`- ${d}`);
+              } else {
+                sections.push(`- **${d.decision}** — ${d.rationale}`);
+              }
+            }
+            sections.push('');
+          }
+
+          // Task status summary
+          if (plan.tasks.length > 0) {
+            sections.push('### Tasks');
+            sections.push('');
+            sections.push('| # | Task | Status |');
+            sections.push('|---|------|--------|');
+            for (let i = 0; i < plan.tasks.length; i++) {
+              const t = plan.tasks[i];
+              sections.push(`| ${i + 1} | ${t.title} | ${t.status} |`);
+            }
+            sections.push('');
+          }
+
+          // Approach
+          if (plan.approach) {
+            sections.push('### Approach');
+            sections.push('');
+            sections.push(plan.approach);
+            sections.push('');
+          }
+
+          // Additional active plans (just IDs)
+          if (activePlans.length > 1) {
+            sections.push('### Other Active Plans');
+            sections.push('');
+            for (let i = 1; i < activePlans.length; i++) {
+              const p = activePlans[i];
+              sections.push(`- **${p.id}**: ${p.objective} (${p.status})`);
+            }
+            sections.push('');
+          }
+        } else {
+          sections.push('## Active Plan');
+          sections.push('');
+          sections.push('No active plans.');
+          sections.push('');
+        }
+
+        // ─── Recent Session Context ────────────────────────
+        const recentSessions = vault.listMemories({
+          type: 'session',
+          projectPath,
+          limit: sessionLimit,
+        });
+
+        if (recentSessions.length > 0) {
+          sections.push('## Recent Sessions');
+          sections.push('');
+          for (const session of recentSessions) {
+            sections.push(`### ${session.createdAt}`);
+            sections.push('');
+            if (session.summary) {
+              sections.push(session.summary);
+              sections.push('');
+            }
+            if (session.nextSteps && session.nextSteps.length > 0) {
+              sections.push('**Next steps:**');
+              for (const step of session.nextSteps) {
+                sections.push(`- ${step}`);
+              }
+              sections.push('');
+            }
+            if (session.decisions && session.decisions.length > 0) {
+              sections.push('**Decisions:**');
+              for (const d of session.decisions) {
+                sections.push(`- ${d}`);
+              }
+              sections.push('');
+            }
+            if (session.filesModified && session.filesModified.length > 0) {
+              sections.push(`**Files modified:** ${session.filesModified.join(', ')}`);
+              sections.push('');
+            }
+          }
+        } else {
+          sections.push('## Recent Sessions');
+          sections.push('');
+          sections.push('No recent session memories found.');
+          sections.push('');
+        }
+
+        // ─── Resumption Hints ──────────────────────────────
+        sections.push('## Resumption');
+        sections.push('');
+        sections.push('Use this document to restore context after a context window transition.');
+        sections.push('');
+        if (activePlans.length > 0) {
+          const plan = activePlans[0];
+          const pendingTasks = plan.tasks.filter(
+            (t) => t.status === 'pending' || t.status === 'in_progress',
+          );
+          if (pendingTasks.length > 0) {
+            sections.push('**Immediate next actions:**');
+            for (const t of pendingTasks.slice(0, 5)) {
+              sections.push(
+                `- ${t.status === 'in_progress' ? '[IN PROGRESS]' : '[PENDING]'} ${t.title}`,
+              );
+            }
+            sections.push('');
+          }
+          if (plan.status === 'executing') {
+            sections.push(
+              '> Plan is in `executing` state. Continue with pending tasks or call `op:plan_reconcile` if complete.',
+            );
+          } else if (plan.status === 'reconciling') {
+            sections.push(
+              '> Plan is in `reconciling` state. Call `op:plan_complete_lifecycle` to finalize.',
+            );
+          }
+        }
+
+        const markdown = sections.join('\n');
+
+        return {
+          handoff: markdown,
+          meta: {
+            activePlanCount: activePlans.length,
+            activePlanId: activePlans.length > 0 ? activePlans[0].id : null,
+            recentSessionCount: recentSessions.length,
+            generatedAt: now,
+          },
+        };
+      },
+    },
+
     // ─── Satellite ops ───────────────────────────────────────────
     ...createMemoryExtraOps(runtime),
     ...createMemoryCrossProjectOps(runtime),

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);
+  });
 });

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

@@ -12,7 +12,7 @@ import { createChainOps } from '../chain-ops.js';
 import { PlanGradeRejectionError } from '../../planning/planner.js';
 
 export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { planner } = runtime;
+  const { planner, vault } = runtime;
 
   return [
     // ─── Planning (inline from core-ops.ts) ─────────────────────
@@ -45,16 +45,35 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           .describe('Rejected alternative approaches — plans with 2+ alternatives score higher'),
       }),
       handler: async (params) => {
+        const objective = params.objective as string;
+        const decisions = ((params.decisions as string[]) ?? []).slice();
+
+        // Vault enrichment: search for patterns matching the objective
+        let vaultEntryIds: string[] = [];
+        try {
+          const results = vault.search(objective, { limit: 5 });
+          if (results.length > 0) {
+            vaultEntryIds = results.map((r) => r.entry.id);
+            for (const r of results) {
+              decisions.push(
+                `Vault pattern: ${r.entry.title ?? r.entry.id} (score: ${r.score.toFixed(2)}) [entryId:${r.entry.id}]`,
+              );
+            }
+          }
+        } catch {
+          // Vault search failed — proceed without enrichment
+        }
+
         const plan = planner.create({
-          objective: params.objective as string,
+          objective,
           scope: params.scope as string,
-          decisions: (params.decisions as string[]) ?? [],
+          decisions,
           tasks: (params.tasks as Array<{ title: string; description: string }>) ?? [],
           alternatives: params.alternatives as
             | Array<{ approach: string; pros: string[]; cons: string[]; rejected_reason: string }>
             | undefined,
         });
-        return { created: true, plan };
+        return { created: true, plan, vaultEntryIds };
       },
     },
     {