@soleri/core 9.2.0 → 9.3.1

package/src/runtime/memory-cross-project-ops.test.ts

@@ -8,9 +8,7 @@ function makeMockRuntime(overrides: Record<string, unknown> = {}) {
     vault: {
       get: vi.fn().mockReturnValue({ id: 'e1', tags: ['pattern'] }),
       update: vi.fn(),
-      searchMemories: vi.fn().mockReturnValue([
-        { id: 'm1', content: 'memory 1' },
-      ]),
+      searchMemories: vi.fn().mockReturnValue([{ id: 'm1', content: 'memory 1' }]),
       search: vi.fn().mockReturnValue([
         { entry: { id: 'g1', tags: ['_global'] }, score: 0.9 },
         { entry: { id: 'g2', tags: ['other'] }, score: 0.8 },
@@ -25,9 +23,9 @@ function makeMockRuntime(overrides: Record<string, unknown> = {}) {
         metadata: { memoryConfig: { crossProjectEnabled: true, extraPaths: ['/extra'] } },
       }),
       register: vi.fn(),
-      getLinkedProjects: vi.fn().mockReturnValue([
-        { project: { path: '/linked', name: 'linked-project' } },
-      ]),
+      getLinkedProjects: vi
+        .fn()
+        .mockReturnValue([{ project: { path: '/linked', name: 'linked-project' } }]),
     },
   } as unknown as AgentRuntime;
 }
@@ -60,7 +58,9 @@ describe('createMemoryCrossProjectOps', () => {
     it('promotes entry by adding _global tag', async () => {
       const runtime = makeMockRuntime();
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'e1',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(true);
       expect(result.tags).toContain('_global');
       expect(runtime.vault.update).toHaveBeenCalledWith('e1', { tags: ['pattern', '_global'] });
@@ -69,7 +69,9 @@ describe('createMemoryCrossProjectOps', () => {
     it('returns error when entry not found', async () => {
       const runtime = makeMockRuntime({ get: vi.fn().mockReturnValue(null) });
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'missing' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'missing',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(false);
       expect(result.error).toContain('Entry not found');
     });
@@ -79,7 +81,9 @@ describe('createMemoryCrossProjectOps', () => {
         get: vi.fn().mockReturnValue({ id: 'e1', tags: ['_global'] }),
       });
       ops = createMemoryCrossProjectOps(runtime);
-      const result = (await findOp('memory_promote_to_global').handler({ entryId: 'e1' })) as Record<string, unknown>;
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'e1',
+      })) as Record<string, unknown>;
       expect(result.promoted).toBe(false);
       expect(result.message).toContain('already promoted');
     });
@@ -132,12 +136,15 @@ describe('createMemoryCrossProjectOps', () => {
       const runtime = makeMockRuntime();
       ops = createMemoryCrossProjectOps(runtime);
       await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       });
 
       // Should search current project, linked project, and extra path
       const searchCalls = (runtime.vault.searchMemories as ReturnType<typeof vi.fn>).mock.calls;
-      const searchedPaths = searchCalls.map((c: unknown[]) => (c[1] as Record<string, unknown>).projectPath);
+      const searchedPaths = searchCalls.map(
+        (c: unknown[]) => (c[1] as Record<string, unknown>).projectPath,
+      );
       expect(searchedPaths).toContain('/test');
       expect(searchedPaths).toContain('/linked');
       expect(searchedPaths).toContain('/extra');
@@ -151,7 +158,8 @@ describe('createMemoryCrossProjectOps', () => {
       ]);
       ops = createMemoryCrossProjectOps(runtime);
       const result = (await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       })) as Record<string, unknown>;
 
       // linkedMemories should be empty because m1 was already in current results
@@ -162,12 +170,15 @@ describe('createMemoryCrossProjectOps', () => {
     it('skips linked search when cross-project disabled', async () => {
       const runtime = makeMockRuntime();
       (runtime.projectRegistry.getByPath as ReturnType<typeof vi.fn>).mockReturnValue({
-        id: 'proj-1', name: 'test', path: '/test',
+        id: 'proj-1',
+        name: 'test',
+        path: '/test',
         metadata: { memoryConfig: { crossProjectEnabled: false } },
       });
       ops = createMemoryCrossProjectOps(runtime);
       const result = (await findOp('memory_cross_project_search').handler({
-        query: 'test', projectPath: '/test',
+        query: 'test',
+        projectPath: '/test',
       })) as Record<string, unknown>;
 
       expect(runtime.projectRegistry.getLinkedProjects).not.toHaveBeenCalled();

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

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createOrchestrateOps } from './orchestrate-ops.js';
+import { assessTaskComplexity } from '../planning/task-complexity-assessor.js';
 import type { AgentRuntime } from './types.js';
 
 // ---------------------------------------------------------------------------
@@ -241,6 +242,73 @@ describe('createOrchestrateOps', () => {
       await op.handler({ planId: 'plan-1', sessionId: 'session-1' });
       expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-1');
     });
+
+    it('works without a preceding plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        summary: 'Fixed a typo in the README',
+      })) as Record<string, unknown>;
+
+      // Should not call planner.complete
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // Should return a lightweight completion record
+      const plan = result.plan as Record<string, unknown>;
+      expect(plan.status).toBe('completed');
+      expect(plan.objective).toBe('Fixed a typo in the README');
+    });
+
+    it('captures knowledge even without plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      await op.handler({
+        sessionId: 'session-1',
+        summary: 'Refactored utility function',
+      });
+
+      // Brain session end and knowledge extraction still run
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-1' }),
+      );
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-1');
+    });
+
+    it('skips anti-rationalization gate when no criteria', async () => {
+      const { detectRationalizations } = await import('../planning/rationalization-detector.js');
+      const op = findOp(ops, 'orchestrate_complete');
+
+      await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        summary: 'This was basically done already',
+      });
+
+      // detectRationalizations should never be called since there are no criteria
+      expect(detectRationalizations).not.toHaveBeenCalled();
+      // Should still complete successfully
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalled();
+    });
+
+    it('still runs brain session end without plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        toolsUsed: ['grep', 'edit'],
+        filesModified: [],
+      })) as Record<string, unknown>;
+
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({
+          action: 'end',
+          sessionId: 'session-1',
+          planOutcome: 'completed',
+          toolsUsed: ['grep', 'edit'],
+        }),
+      );
+      expect(result.session).toBeDefined();
+    });
   });
 
   // ─── orchestrate_status ───────────────────────────────────────
@@ -299,4 +367,140 @@ describe('createOrchestrateOps', () => {
       await expect(op.handler({ planId: 'missing' })).rejects.toThrow('not found');
     });
   });
+
+  // ─── task auto-assessment routing ────────────────────────────
+  //
+  // Integration-style tests that verify the full assess → route → complete flow:
+  // 1. Use TaskComplexityAssessor to classify the task
+  // 2. Route to direct execution (simple) or planning (complex)
+  // 3. Complete via orchestrate_complete in both paths
+
+  describe('task auto-assessment routing', () => {
+    it('simple task routes to direct execution + complete', async () => {
+      // Step 1: Assess — "fix typo in README" should be simple
+      const assessment = assessTaskComplexity({ prompt: 'fix typo in README' });
+      expect(assessment.classification).toBe('simple');
+
+      // Step 2: Skip planning, go straight to complete without a planId
+      const completeOp = findOp(ops, 'orchestrate_complete');
+      const result = (await completeOp.handler({
+        sessionId: 'session-simple',
+        outcome: 'completed',
+        summary: 'Fixed typo in README',
+      })) as Record<string, unknown>;
+
+      // Should not touch the planner at all
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // Should still produce a valid completion record
+      const plan = result.plan as Record<string, unknown>;
+      expect(plan.status).toBe('completed');
+      expect(plan.objective).toBe('Fixed typo in README');
+
+      // Knowledge should still be captured
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-simple');
+    });
+
+    it('complex task routes through planning + complete', async () => {
+      // Step 1: Assess — cross-cutting auth task should be complex
+      const assessment = assessTaskComplexity({
+        prompt: 'add authentication across all API routes',
+        filesEstimated: 8,
+      });
+      expect(assessment.classification).toBe('complex');
+
+      // Step 2: Create a plan via orchestrate_plan
+      const planOp = findOp(ops, 'orchestrate_plan');
+      const planResult = (await planOp.handler({
+        prompt: 'add authentication across all API routes',
+      })) as Record<string, unknown>;
+      expect(planResult).toHaveProperty('plan');
+      expect(planResult).toHaveProperty('flow');
+
+      // Step 3: Complete with the planId
+      const completeOp = findOp(ops, 'orchestrate_complete');
+      const result = (await completeOp.handler({
+        planId: 'plan-1',
+        sessionId: 'session-complex',
+        outcome: 'completed',
+        summary: 'Added authentication middleware to all API routes',
+      })) as Record<string, unknown>;
+
+      // Should complete via the planner lifecycle
+      expect(rt.planner.complete).toHaveBeenCalledWith('plan-1');
+
+      // Knowledge should be captured
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-complex' }),
+      );
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-complex');
+
+      // Plan should be marked completed
+      const completedPlan = result.plan as Record<string, unknown>;
+      expect(completedPlan.status).toBe('completed');
+    });
+
+    it('orchestrate_complete captures knowledge in both paths', async () => {
+      const completeOp = findOp(ops, 'orchestrate_complete');
+
+      // ── Simple path (no planId) ──
+      vi.clearAllMocks();
+      rt = mockRuntime();
+      ops = createOrchestrateOps(rt);
+
+      await findOp(ops, 'orchestrate_complete').handler({
+        sessionId: 'session-simple',
+        outcome: 'completed',
+        summary: 'Renamed a variable',
+      });
+
+      // Brain session end called
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-simple' }),
+      );
+      // Knowledge extraction called
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-simple');
+      // Planner.complete NOT called (no plan)
+      expect(rt.planner.complete).not.toHaveBeenCalled();
+
+      // ── Complex path (with planId) ──
+      vi.clearAllMocks();
+      rt = mockRuntime();
+      ops = createOrchestrateOps(rt);
+
+      await findOp(ops, 'orchestrate_complete').handler({
+        planId: 'plan-1',
+        sessionId: 'session-complex',
+        outcome: 'completed',
+        summary: 'Implemented full auth layer',
+      });
+
+      // Brain session end called
+      expect(rt.brainIntelligence.lifecycle).toHaveBeenCalledWith(
+        expect.objectContaining({ action: 'end', sessionId: 'session-complex' }),
+      );
+      // Knowledge extraction called
+      expect(rt.brainIntelligence.extractKnowledge).toHaveBeenCalledWith('session-complex');
+      // Planner.complete IS called (has plan)
+      expect(rt.planner.complete).toHaveBeenCalledWith('plan-1');
+    });
+
+    it('assessment result includes non-empty reasoning for simple tasks', () => {
+      const result = assessTaskComplexity({ prompt: 'fix typo in README' });
+      expect(result.classification).toBe('simple');
+      expect(typeof result.reasoning).toBe('string');
+      expect(result.reasoning.length).toBeGreaterThan(0);
+    });
+
+    it('assessment result includes non-empty reasoning for complex tasks', () => {
+      const result = assessTaskComplexity({
+        prompt: 'add authentication across all API routes',
+        filesEstimated: 8,
+        domains: ['auth', 'api', 'middleware'],
+      });
+      expect(result.classification).toBe('complex');
+      expect(typeof result.reasoning).toBe('string');
+      expect(result.reasoning.length).toBeGreaterThan(0);
+    });
+  });
 });

package/src/runtime/orchestrate-ops.ts

@@ -182,10 +182,7 @@ function buildHealthWarning(
  * Collect all acceptance criteria from a plan's tasks.
  * Returns empty array if plan not found or has no criteria (graceful skip).
  */
-function collectAcceptanceCriteria(
-  plannerRef: AgentRuntime['planner'],
-  planId: string,
-): string[] {
+function collectAcceptanceCriteria(plannerRef: AgentRuntime['planner'], planId: string): string[] {
   const plan = plannerRef.get(planId);
   if (!plan) return [];
   const criteria: string[] = [];
@@ -210,7 +207,8 @@ function captureRationalizationAntiPattern(
     vaultRef.add({
       id: `antipattern-rationalization-${Date.now()}`,
       title: 'Rationalization detected in completion claim',
-      description: `Detected rationalization patterns: ${patterns}. ` +
+      description:
+        `Detected rationalization patterns: ${patterns}. ` +
         `Items: ${report.items.map((i) => `"${i.phrase}" (${i.pattern})`).join('; ')}.`,
       type: 'anti-pattern',
       domain: 'planning',
@@ -247,7 +245,10 @@ export function createOrchestrateOps(
         'a pruned orchestration plan with gate-guarded steps.',
       auth: 'write',
       schema: z.object({
-        prompt: z.string().optional().describe('Natural language description of what to do (or use objective)'),
+        prompt: z
+          .string()
+          .optional()
+          .describe('Natural language description of what to do (or use objective)'),
         projectPath: z.string().optional().default('.').describe('Project root path'),
         // Legacy params — still accepted for backward compat
         objective: z.string().optional().describe('(Legacy) Plan objective — use prompt instead'),
@@ -277,9 +278,10 @@ export function createOrchestrateOps(
           recommendations = raw.map((r) => {
             // Look up vault entry ID by title for feedback tracking
             const entries = vault.search(r.pattern, { limit: 1 });
-            const entryId = entries.length > 0 && entries[0].entry.title === r.pattern
-              ? entries[0].entry.id
-              : undefined;
+            const entryId =
+              entries.length > 0 && entries[0].entry.title === r.pattern
+                ? entries[0].entry.id
+                : undefined;
             return { pattern: r.pattern, strength: r.strength, entryId };
           });
         } catch {
@@ -307,12 +309,10 @@ export function createOrchestrateOps(
         planStore.set(plan.planId, { plan, createdAt: Date.now() });
 
         // 5. Also create a planner plan for lifecycle tracking (backward compat)
-        const decisions = recommendations.map(
-          (r) => {
-            const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
-            return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
-          },
-        );
+        const decisions = recommendations.map((r) => {
+          const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
+          return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
+        });
         const tasks = (params.tasks as Array<{ title: string; description: string }>) ?? [];
 
         // 5b. Extract GitHub issue context if prompt references #NNN
@@ -333,7 +333,8 @@ export function createOrchestrateOps(
           }
         }
 
-        const planObjective = (params as Record<string, unknown>)._enrichedObjective as string | undefined ?? prompt;
+        const planObjective =
+          ((params as Record<string, unknown>)._enrichedObjective as string | undefined) ?? prompt;
 
         let legacyPlan;
         try {
@@ -471,22 +472,32 @@ export function createOrchestrateOps(
         'end brain session, and clean up.',
       auth: 'write',
       schema: z.object({
-        planId: z.string().describe('ID of the executing plan to complete'),
+        planId: z.string().optional().describe('ID of the executing plan to complete (optional for direct tasks)'),
         sessionId: z.string().describe('ID of the brain session to end'),
         outcome: z
           .enum(['completed', 'abandoned', 'partial'])
           .optional()
           .default('completed')
           .describe('Plan outcome'),
-        summary: z.string().optional().describe('Completion summary — checked for rationalization language'),
+        summary: z
+          .string()
+          .optional()
+          .describe('Completion summary — checked for rationalization language'),
         toolsUsed: z.array(z.string()).optional().describe('Tools used during execution'),
         filesModified: z.array(z.string()).optional().describe('Files modified during execution'),
-        projectPath: z.string().optional().default('.').describe('Project root path for impact analysis'),
-        overrideRationalization: z.boolean().optional().default(false)
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project root path for impact analysis'),
+        overrideRationalization: z
+          .boolean()
+          .optional()
+          .default(false)
           .describe('Set true to bypass rationalization gate and impact warnings after review'),
       }),
       handler: async (params) => {
-        const planId = params.planId as string;
+        const planId = params.planId as string | undefined;
         const sessionId = params.sessionId as string;
         const outcome = (params.outcome as string) ?? 'completed';
         const completionSummary = (params.summary as string) ?? '';
@@ -494,20 +505,21 @@ export function createOrchestrateOps(
         const filesModified = (params.filesModified as string[]) ?? [];
         const overrideRationalization = (params.overrideRationalization as boolean) ?? false;
 
-        // Anti-rationalization gate: check completion summary before completing
-        if (outcome === 'completed' && !overrideRationalization) {
-          const criteria = collectAcceptanceCriteria(planner, planId);
-          if (criteria.length > 0 && completionSummary) {
-            const report = detectRationalizations(criteria, completionSummary);
-            if (report.detected) {
-              captureRationalizationAntiPattern(vault, report);
-              return {
-                blocked: true,
-                reason: 'Rationalization language detected in completion summary',
-                rationalization: report,
-                hint: 'Address the unmet criteria, or set overrideRationalization: true to bypass this gate.',
-              };
-            }
+        // Look up plan — optional for direct tasks that skipped planning
+        const planObj = planId ? planner.get(planId) : null;
+
+        // Anti-rationalization gate: only if we have acceptance criteria from a plan
+        const criteria = planObj && planId ? collectAcceptanceCriteria(planner, planId) : [];
+        if (outcome === 'completed' && criteria.length > 0 && completionSummary && !overrideRationalization) {
+          const report = detectRationalizations(criteria, completionSummary);
+          if (report.detected) {
+            captureRationalizationAntiPattern(vault, report);
+            return {
+              blocked: true,
+              reason: 'Rationalization language detected in completion summary',
+              rationalization: report,
+              hint: 'Address the unmet criteria, or set overrideRationalization: true to bypass this gate.',
+            };
           }
         }
 
@@ -516,10 +528,7 @@ export function createOrchestrateOps(
         if (filesModified.length > 0) {
           try {
             const analyzer = new ImpactAnalyzer();
-            const planObj = planner.get(planId);
-            const scopeHints = planObj?.scope
-              ? [planObj.scope]
-              : undefined;
+            const scopeHints = planObj?.scope ? [planObj.scope] : undefined;
             impactReport = analyzer.analyzeImpact(
               filesModified,
               (params.projectPath as string) ?? '.',
@@ -540,10 +549,19 @@ export function createOrchestrateOps(
           }
         }
 
-        // Complete the planner plan (legacy lifecycle)
-        const plan = planner.complete(planId);
+        // Complete the planner plan (legacy lifecycle) — only if plan exists
+        let completedPlan;
+        if (planObj && planId) {
+          completedPlan = planner.complete(planId);
+        } else {
+          completedPlan = {
+            id: planId ?? `direct-${Date.now()}`,
+            status: 'completed',
+            objective: completionSummary || 'Direct execution',
+          };
+        }
 
-        // End brain session
+        // End brain session — runs regardless of plan existence
         const session = brainIntelligence.lifecycle({
           action: 'end',
           sessionId,
@@ -553,7 +571,7 @@ export function createOrchestrateOps(
           filesModified,
         });
 
-        // Extract knowledge
+        // Extract knowledge — runs regardless of plan existence
         let extraction = null;
         try {
           extraction = brainIntelligence.extractKnowledge(sessionId);
@@ -563,27 +581,29 @@ export function createOrchestrateOps(
 
         // Run flow-engine epilogue if we have a flow plan
         let epilogueResult = null;
-        const entry = planStore.get(planId);
-        if (entry) {
-          try {
-            const dispatch = buildDispatch(agentId, runtime, facades);
-            const summary = `${outcome}: ${entry.plan.summary}. Tools: ${toolsUsed.join(', ') || 'none'}. Files: ${filesModified.join(', ') || 'none'}.`;
-            epilogueResult = await runEpilogue(
-              dispatch,
-              entry.plan.context.probes,
-              entry.plan.context.projectPath,
-              summary,
-            );
-          } catch {
-            // Epilogue is best-effort
-          }
+        if (planId) {
+          const entry = planStore.get(planId);
+          if (entry) {
+            try {
+              const dispatch = buildDispatch(agentId, runtime, facades);
+              const summary = `${outcome}: ${entry.plan.summary}. Tools: ${toolsUsed.join(', ') || 'none'}. Files: ${filesModified.join(', ') || 'none'}.`;
+              epilogueResult = await runEpilogue(
+                dispatch,
+                entry.plan.context.probes,
+                entry.plan.context.projectPath,
+                summary,
+              );
+            } catch {
+              // Epilogue is best-effort
+            }
 
-          // Clean up plan store
-          planStore.delete(planId);
+            // Clean up plan store
+            planStore.delete(planId);
+          }
         }
 
         return {
-          plan,
+          plan: completedPlan,
           session,
           extraction,
           epilogue: epilogueResult,
@@ -710,11 +730,22 @@ export function createOrchestrateOps(
       auth: 'write',
       schema: z.object({
         planId: z.string().describe('ID of the plan to project to GitHub'),
-        projectPath: z.string().optional().default('.').describe('Project root path for git detection'),
+        projectPath: z
+          .string()
+          .optional()
+          .default('.')
+          .describe('Project root path for git detection'),
         milestone: z.number().optional().describe('GitHub milestone number to assign issues to'),
         labels: z.array(z.string()).optional().describe('Labels to apply to created issues'),
-        linkToIssue: z.number().optional().describe('Existing issue number to link plan to instead of creating new issues'),
-        dryRun: z.boolean().optional().default(false).describe('Preview what would be created without actually creating issues'),
+        linkToIssue: z
+          .number()
+          .optional()
+          .describe('Existing issue number to link plan to instead of creating new issues'),
+        dryRun: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Preview what would be created without actually creating issues'),
       }),
       handler: async (params) => {
         const planId = params.planId as string;
@@ -729,7 +760,9 @@ export function createOrchestrateOps(
         if (!plan) throw new Error(`Plan not found: ${planId}`);
 
         if (plan.tasks.length === 0) {
-          throw new Error('Plan has no tasks — run plan_split first to define tasks before projecting to GitHub');
+          throw new Error(
+            'Plan has no tasks — run plan_split first to define tasks before projecting to GitHub',
+          );
         }
 
         // 2. Detect GitHub context
@@ -807,7 +840,12 @@ export function createOrchestrateOps(
 
         // 6. Create issues per task (with duplicate detection)
         const created: Array<{ taskId: string; issueNumber: number; title: string }> = [];
-        const skipped: Array<{ taskId: string; title: string; existingIssue: number; reason: string }> = [];
+        const skipped: Array<{
+          taskId: string;
+          title: string;
+          existingIssue: number;
+          reason: string;
+        }> = [];
         const failed: Array<{ taskId: string; title: string; reason: string }> = [];
 
         for (const task of plan.tasks) {