@soleri/core 9.7.2 → 9.8.0

package/src/planning/plan-lifecycle.test.ts

@@ -342,6 +342,55 @@ describe('plan-lifecycle', () => {
       expect(task.completedAt).toBeGreaterThan(0);
       expect(task.status).toBe('failed');
     });
+
+    it('increments fixIterations on completed → in_progress rework', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'completed');
+      expect(task.fixIterations).toBeUndefined();
+      // Rework: send back from completed to in_progress
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBe(1);
+      expect(task.completedAt).toBeUndefined();
+    });
+
+    it('increments fixIterations on failed → in_progress rework', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'failed');
+      // Rework from failed
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBe(1);
+      expect(task.completedAt).toBeUndefined();
+    });
+
+    it('accumulates fixIterations across multiple rework cycles', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'completed');
+      applyTaskStatusUpdate(task, 'in_progress'); // rework 1
+      applyTaskStatusUpdate(task, 'completed');
+      applyTaskStatusUpdate(task, 'in_progress'); // rework 2
+      expect(task.fixIterations).toBe(2);
+    });
+
+    it('does not increment fixIterations on pending → in_progress', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBeUndefined();
+    });
+
+    it('resets completedAt on rework but preserves startedAt', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      const originalStartedAt = task.startedAt;
+      applyTaskStatusUpdate(task, 'completed');
+      expect(task.completedAt).toBeGreaterThan(0);
+      // Rework
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.completedAt).toBeUndefined();
+      expect(task.startedAt).toBe(originalStartedAt);
+    });
   });
 
   describe('createPlanObject', () => {

package/src/planning/plan-lifecycle.ts

@@ -338,6 +338,11 @@ export function applyIteration(plan: Plan, changes: IterateChanges): number {
  */
 export function applyTaskStatusUpdate(task: PlanTask, status: TaskStatus): void {
   const now = Date.now();
+  // Rework detection: completed/failed → in_progress means a fix iteration
+  if (status === 'in_progress' && (task.status === 'completed' || task.status === 'failed')) {
+    task.fixIterations = (task.fixIterations ?? 0) + 1;
+    task.completedAt = undefined;
+  }
   if (status === 'in_progress' && !task.startedAt) task.startedAt = now;
   if (status === 'completed' || status === 'skipped' || status === 'failed') {
     task.completedAt = now;

package/src/planning/planner-types.ts

@@ -88,6 +88,8 @@ export interface PlanTask {
   deliverables?: TaskDeliverable[];
   /** Verification findings for tasks that modify existing code. Advisory only. */
   verification?: TaskVerification;
+  /** Number of times this task was sent back for rework (completed → in_progress). */
+  fixIterations?: number;
   updatedAt: number;
 }
 

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

@@ -75,6 +75,20 @@ vi.mock('../planning/impact-analyzer.js', () => ({
   })),
 }));
 
+vi.mock('../planning/evidence-collector.js', () => ({
+  collectGitEvidence: vi.fn().mockReturnValue({
+    planId: 'plan-1',
+    planObjective: 'test',
+    accuracy: 85,
+    evidenceSources: ['git'],
+    taskEvidence: [],
+    unplannedChanges: [],
+    missingWork: [],
+    verificationGaps: [],
+    summary: '0/0 tasks verified by git evidence',
+  }),
+}));
+
 // ---------------------------------------------------------------------------
 // Mock runtime
 // ---------------------------------------------------------------------------
@@ -88,7 +102,9 @@ function mockRuntime(): AgentRuntime {
       stats: vi.fn().mockReturnValue({ totalEntries: 10, byDomain: {}, byType: {} }),
       captureMemory: vi.fn(),
     },
-    brain: {},
+    brain: {
+      recordFeedback: vi.fn(),
+    },
     brainIntelligence: {
       recommend: vi.fn().mockReturnValue([]),
       lifecycle: vi.fn().mockReturnValue({ id: 'session-1' }),
@@ -318,6 +334,67 @@ describe('createOrchestrateOps', () => {
       );
       expect(result.session).toBeDefined();
     });
+
+    it('includes evidenceReport when completing a plan', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        planId: 'plan-1',
+        sessionId: 'session-1',
+        outcome: 'completed',
+        projectPath: '.',
+      })) as Record<string, unknown>;
+
+      expect(result).toHaveProperty('evidenceReport');
+      const report = result.evidenceReport as Record<string, unknown>;
+      expect(report.accuracy).toBe(85);
+      expect(report.evidenceSources).toEqual(['git']);
+    });
+
+    it('succeeds without blocking when git is unavailable', async () => {
+      const { collectGitEvidence } = await import('../planning/evidence-collector.js');
+      vi.mocked(collectGitEvidence).mockImplementationOnce(() => {
+        throw new Error('git not found');
+      });
+
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        planId: 'plan-1',
+        sessionId: 'session-1',
+        outcome: 'completed',
+      })) as Record<string, unknown>;
+
+      // Should complete successfully without evidenceReport
+      expect(result).toHaveProperty('plan');
+      expect(result).toHaveProperty('session');
+      expect(result).not.toHaveProperty('evidenceReport');
+    });
+
+    it('adds warning when evidence accuracy is below 50%', async () => {
+      const { collectGitEvidence } = await import('../planning/evidence-collector.js');
+      vi.mocked(collectGitEvidence).mockReturnValueOnce({
+        planId: 'plan-1',
+        planObjective: 'test',
+        accuracy: 30,
+        evidenceSources: ['git'],
+        taskEvidence: [],
+        unplannedChanges: [],
+        missingWork: [],
+        verificationGaps: [],
+        summary: '0/2 tasks verified by git evidence',
+      });
+
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        planId: 'plan-1',
+        sessionId: 'session-1',
+        outcome: 'completed',
+      })) as Record<string, unknown>;
+
+      expect(result).toHaveProperty('evidenceReport');
+      expect(result).toHaveProperty('warnings');
+      const warnings = result.warnings as string[];
+      expect(warnings.some((w) => w.includes('Low evidence accuracy (30%)'))).toBe(true);
+    });
   });
 
   // ─── orchestrate_status ───────────────────────────────────────

package/src/runtime/orchestrate-ops.ts

@@ -38,7 +38,10 @@ import {
 import { detectRationalizations } from '../planning/rationalization-detector.js';
 import { ImpactAnalyzer } from '../planning/impact-analyzer.js';
 import type { ImpactReport } from '../planning/impact-analyzer.js';
+import { collectGitEvidence } from '../planning/evidence-collector.js';
+import type { EvidenceReport } from '../planning/evidence-collector.js';
 import { recordPlanFeedback } from './plan-feedback-helper.js';
+import { analyzeQualitySignals, captureQualitySignals } from './quality-signals.js';
 
 // ---------------------------------------------------------------------------
 // Intent detection — keyword-based mapping from prompt to intent
@@ -741,10 +744,30 @@ export function createOrchestrateOps(
           }
         }
 
+        const warnings: string[] = [];
+
+        // Evidence-based reconciliation: cross-reference plan tasks against git diff
+        let evidenceReport: EvidenceReport | null = null;
+        if (planObj && outcome === 'completed') {
+          try {
+            evidenceReport = collectGitEvidence(
+              planObj,
+              (params.projectPath as string) ?? '.',
+              'main',
+            );
+            if (evidenceReport.accuracy < 50) {
+              warnings.push(
+                `Low evidence accuracy (${evidenceReport.accuracy}%) — plan tasks may not match git changes.`,
+              );
+            }
+          } catch {
+            // Evidence collection is best-effort — never blocks
+          }
+        }
+
         // Complete the planner plan (legacy lifecycle) — best-effort
         // The epilogue (brain session, knowledge extraction, flow epilogue) MUST run
         // even if plan transition fails (e.g. already completed, missing, invalid state).
-        const warnings: string[] = [];
         let completedPlan;
         if (planObj && planId) {
           try {
@@ -788,6 +811,33 @@ export function createOrchestrateOps(
           }
         }
 
+        // Feed evidence accuracy into brain feedback — low accuracy signals poor pattern match
+        if (evidenceReport && planObj) {
+          try {
+            const evidenceAction = evidenceReport.accuracy < 50 ? 'dismissed' : 'accepted';
+            brain.recordFeedback(`plan-evidence:${planObj.objective}`, planObj.id, evidenceAction);
+          } catch {
+            // Evidence brain feedback is best-effort
+          }
+        }
+
+        // Quality signals: capture rework anti-patterns and clean-task feedback
+        if (evidenceReport) {
+          try {
+            const qualityAnalysis = analyzeQualitySignals(evidenceReport, planObj);
+            if (qualityAnalysis.antiPatterns.length > 0 || qualityAnalysis.cleanTasks.length > 0) {
+              captureQualitySignals(
+                qualityAnalysis,
+                vault,
+                brain,
+                planId ?? `direct-${Date.now()}`,
+              );
+            }
+          } catch {
+            // Quality signal capture is best-effort — never blocks completion
+          }
+        }
+
         // Extract knowledge — runs regardless of plan existence
         let extraction = null;
         try {
@@ -840,6 +890,7 @@ export function createOrchestrateOps(
           extraction,
           epilogue: epilogueResult,
           ...(impactReport ? { impactAnalysis: impactReport } : {}),
+          ...(evidenceReport ? { evidenceReport } : {}),
           ...(warnings.length > 0 ? { warnings } : {}),
         };
       },
@@ -890,6 +941,44 @@ export function createOrchestrateOps(
           createdAt: e.createdAt,
         }));
 
+        // Compute readiness for the most recent active plan
+        const TERMINAL_TASK_STATES = new Set(['completed', 'skipped', 'failed']);
+        let readiness: {
+          allTasksTerminal: boolean;
+          terminalCount: number;
+          totalCount: number;
+          idleSince: number | null;
+        } | null = null;
+
+        const executingPlans = activePlans.filter(
+          (p: { status: string }) => p.status === 'executing',
+        );
+        if (executingPlans.length > 0) {
+          const plan = executingPlans[0] as {
+            tasks?: Array<{ status: string; completedAt?: number; startedAt?: number }>;
+            updatedAt?: number;
+          };
+          const tasks = plan.tasks ?? [];
+          const totalCount = tasks.length;
+          const terminalCount = tasks.filter((t) => TERMINAL_TASK_STATES.has(t.status)).length;
+          const allTasksTerminal = totalCount > 0 && terminalCount === totalCount;
+
+          // idleSince: the most recent completedAt among terminal tasks, or plan updatedAt
+          let idleSince: number | null = null;
+          if (totalCount > 0 && !allTasksTerminal) {
+            const terminalTimestamps = tasks
+              .filter((t) => TERMINAL_TASK_STATES.has(t.status) && t.completedAt)
+              .map((t) => t.completedAt as number);
+            if (terminalTimestamps.length > 0) {
+              idleSince = Math.max(...terminalTimestamps);
+            } else if (plan.updatedAt) {
+              idleSince = plan.updatedAt;
+            }
+          }
+
+          readiness = { allTasksTerminal, terminalCount, totalCount, idleSince };
+        }
+
         return {
           activePlans,
           sessionContext,
@@ -897,6 +986,7 @@ export function createOrchestrateOps(
           recommendations,
           brainStats,
           flowPlans,
+          ...(readiness ? { readiness } : {}),
         };
       },
     },

package/src/runtime/orchestrate-status-readiness.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Tests for orchestrate_status readiness field.
+ *
+ * Validates that orchestrate_status computes readiness
+ * based on the active plan's task states.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createOrchestrateOps } from './orchestrate-ops.js';
+import { captureOps } from '../engine/test-helpers.js';
+import { createAgentRuntime } from './runtime.js';
+import type { AgentRuntime } from './types.js';
+
+let runtime: AgentRuntime;
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = join(tmpdir(), `readiness-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+  runtime = createAgentRuntime({
+    agentId: 'test-readiness',
+    vaultPath: ':memory:',
+    plansPath: join(tempDir, 'plans.json'),
+  });
+});
+
+afterEach(() => {
+  runtime.close();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+/** Helper: call the orchestrate_status handler directly. */
+async function callStatus(rt: AgentRuntime): Promise<Record<string, unknown>> {
+  const ops = captureOps(createOrchestrateOps(rt));
+  const op = ops.get('orchestrate_status')!;
+  return (await op.handler({})) as Record<string, unknown>;
+}
+
+/** Helper: create an executing plan with N tasks, return plan + task IDs. */
+function createExecutingPlan(
+  rt: AgentRuntime,
+  tasks: Array<{ title: string; description: string }>,
+) {
+  const plan = rt.planner.create({
+    objective: 'Test plan',
+    scope: 'test',
+    decisions: [],
+    tasks: [],
+  });
+  rt.planner.approve(plan.id);
+  rt.planner.splitTasks(plan.id, tasks);
+  rt.planner.startExecution(plan.id);
+  const executing = rt.planner.get(plan.id)!;
+  return { planId: plan.id, tasks: executing.tasks };
+}
+
+describe('orchestrate_status readiness', () => {
+  it('returns no readiness when there are no executing plans', async () => {
+    const data = await callStatus(runtime);
+    expect(data.readiness).toBeUndefined();
+  });
+
+  it('returns readiness with allTasksTerminal=true when all tasks are done', async () => {
+    const { planId, tasks } = createExecutingPlan(runtime, [
+      { title: 'Task A', description: 'Do A' },
+      { title: 'Task B', description: 'Do B' },
+    ]);
+
+    for (const task of tasks) {
+      runtime.planner.updateTask(planId, task.id, 'completed');
+    }
+
+    const data = await callStatus(runtime);
+    const readiness = data.readiness as {
+      allTasksTerminal: boolean;
+      terminalCount: number;
+      totalCount: number;
+      idleSince: number | null;
+    };
+
+    expect(readiness).toBeDefined();
+    expect(readiness.allTasksTerminal).toBe(true);
+    expect(readiness.terminalCount).toBe(2);
+    expect(readiness.totalCount).toBe(2);
+    expect(readiness.idleSince).toBeNull();
+  });
+
+  it('returns readiness with mixed task states', async () => {
+    const { planId, tasks } = createExecutingPlan(runtime, [
+      { title: 'Task X', description: 'Do X' },
+      { title: 'Task Y', description: 'Do Y' },
+      { title: 'Task Z', description: 'Do Z' },
+    ]);
+
+    runtime.planner.updateTask(planId, tasks[0].id, 'completed');
+    runtime.planner.updateTask(planId, tasks[1].id, 'skipped');
+    // tasks[2] remains pending
+
+    const data = await callStatus(runtime);
+    const readiness = data.readiness as {
+      allTasksTerminal: boolean;
+      terminalCount: number;
+      totalCount: number;
+      idleSince: number | null;
+    };
+
+    expect(readiness).toBeDefined();
+    expect(readiness.allTasksTerminal).toBe(false);
+    expect(readiness.terminalCount).toBe(2);
+    expect(readiness.totalCount).toBe(3);
+  });
+
+  it('includes failed tasks in terminal count', async () => {
+    const { planId, tasks } = createExecutingPlan(runtime, [
+      { title: 'Task F', description: 'Fail' },
+    ]);
+
+    runtime.planner.updateTask(planId, tasks[0].id, 'failed');
+
+    const data = await callStatus(runtime);
+    const readiness = data.readiness as {
+      allTasksTerminal: boolean;
+      terminalCount: number;
+      totalCount: number;
+      idleSince: number | null;
+    };
+
+    expect(readiness).toBeDefined();
+    expect(readiness.allTasksTerminal).toBe(true);
+    expect(readiness.terminalCount).toBe(1);
+    expect(readiness.totalCount).toBe(1);
+  });
+
+  it('computes idleSince from last terminal task timestamp', async () => {
+    const { planId, tasks } = createExecutingPlan(runtime, [
+      { title: 'Done', description: 'Already done' },
+      { title: 'Pending', description: 'Still pending' },
+    ]);
+
+    runtime.planner.updateTask(planId, tasks[0].id, 'completed');
+    // tasks[1] remains pending
+
+    const data = await callStatus(runtime);
+    const readiness = data.readiness as {
+      allTasksTerminal: boolean;
+      terminalCount: number;
+      totalCount: number;
+      idleSince: number | null;
+    };
+
+    expect(readiness).toBeDefined();
+    expect(readiness.allTasksTerminal).toBe(false);
+    expect(readiness.terminalCount).toBe(1);
+    expect(readiness.totalCount).toBe(2);
+    // idleSince should be set (either from completedAt or updatedAt)
+    expect(readiness.idleSince).not.toBeNull();
+    expect(typeof readiness.idleSince).toBe('number');
+  });
+});