@soleri/core 9.0.3 → 9.2.0

package/src/persona/prompt-generator.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import { generatePersonaInstructions, getRandomSignoff } from './prompt-generator.js';
+import type { PersonaConfig } from './types.js';
+import { createDefaultPersona } from './defaults.js';
+
+function makeBlankPersona(name = 'TestBot'): PersonaConfig {
+  return {
+    name,
+    template: 'none',
+    inspiration: '',
+    culture: '',
+    metaphors: [],
+    voice: '',
+    traits: [],
+    quirks: [],
+    opinions: [],
+    languageRule: '',
+    nameRule: '',
+    greetings: [],
+    signoffs: [],
+  };
+}
+
+describe('generatePersonaInstructions', () => {
+  it('returns generic instructions for blank persona', () => {
+    const blank = makeBlankPersona('BlankBot');
+    const result = generatePersonaInstructions(blank);
+    expect(result.instructions).toContain('BlankBot');
+    expect(result.instructions).toContain('No persona configured');
+    expect(result.greeting).toContain('BlankBot');
+  });
+
+  it('generates full instructions for a configured persona', () => {
+    const persona = createDefaultPersona('Artisan');
+    const result = generatePersonaInstructions(persona);
+
+    expect(result.instructions).toContain('# Persona: Artisan');
+    expect(result.instructions).toContain('## Voice');
+    expect(result.instructions).toContain('## Personality Traits');
+    expect(result.instructions).toContain('## Character Quirks');
+    expect(result.instructions).toContain('## Cultural Texture');
+    expect(result.instructions).toContain('## Metaphor Domain');
+    expect(result.instructions).toContain('## Opinions');
+    expect(result.instructions).toContain('## Identity Persistence');
+    expect(result.instructions).toContain('## Important');
+  });
+
+  it('includes inspiration when present', () => {
+    const persona = createDefaultPersona('A');
+    const result = generatePersonaInstructions(persona);
+    expect(result.instructions).toContain('inspired by');
+  });
+
+  it('omits sections when arrays are empty', () => {
+    const persona: PersonaConfig = {
+      ...makeBlankPersona('Minimal'),
+      template: 'custom',
+      voice: 'Calm',
+    };
+    const result = generatePersonaInstructions(persona);
+    expect(result.instructions).not.toContain('## Personality Traits');
+    expect(result.instructions).not.toContain('## Character Quirks');
+    expect(result.instructions).not.toContain('## Metaphor Domain');
+    expect(result.instructions).not.toContain('## Opinions');
+  });
+
+  it('omits cultural section when culture is empty', () => {
+    const persona: PersonaConfig = {
+      ...makeBlankPersona(),
+      template: 'custom',
+      voice: 'Direct',
+    };
+    const result = generatePersonaInstructions(persona);
+    expect(result.instructions).not.toContain('## Cultural Texture');
+  });
+
+  it('omits identity persistence when nameRule is empty', () => {
+    const persona: PersonaConfig = {
+      ...makeBlankPersona(),
+      template: 'custom',
+      voice: 'Direct',
+      nameRule: '',
+    };
+    const result = generatePersonaInstructions(persona);
+    expect(result.instructions).not.toContain('## Identity Persistence');
+  });
+
+  it('picks greeting from pool when available', () => {
+    const persona: PersonaConfig = {
+      ...makeBlankPersona(),
+      template: 'custom',
+      voice: 'Warm',
+      greetings: ['Ciao!'],
+    };
+    const result = generatePersonaInstructions(persona);
+    expect(result.greeting).toBe('Ciao!');
+  });
+
+  it('falls back to generic greeting when pool is empty', () => {
+    const persona: PersonaConfig = {
+      ...makeBlankPersona('NoGreet'),
+      template: 'custom',
+      voice: 'Cool',
+      greetings: [],
+    };
+    const result = generatePersonaInstructions(persona);
+    expect(result.greeting).toContain('NoGreet');
+  });
+});
+
+describe('getRandomSignoff', () => {
+  it('returns a signoff from the pool', () => {
+    const persona = createDefaultPersona('Agent');
+    const signoff = getRandomSignoff(persona);
+    expect(persona.signoffs).toContain(signoff);
+  });
+
+  it('returns fallback when signoffs array is empty', () => {
+    const persona = makeBlankPersona();
+    expect(getRandomSignoff(persona)).toBe('Until next time!');
+  });
+
+  it('returns the only signoff when pool has one entry', () => {
+    const persona: PersonaConfig = { ...makeBlankPersona(), signoffs: ['Bye!'] };
+    expect(getRandomSignoff(persona)).toBe('Bye!');
+  });
+});

package/src/planning/evidence-collector.test.ts

@@ -0,0 +1,406 @@
+/**
+ * Tests for evidence-collector.ts — git evidence collection and
+ * verification gap detection for plan reconciliation.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { Plan, PlanTask } from './planner.js';
+import type { GitTaskEvidence } from './evidence-collector.js';
+import { collectGitEvidence, collectVerificationGaps } from './evidence-collector.js';
+
+// Mock child_process.execFileSync
+vi.mock('node:child_process', () => ({
+  execFileSync: vi.fn(),
+}));
+
+import { execFileSync } from 'node:child_process';
+const mockExecFileSync = vi.mocked(execFileSync);
+
+function makePlan(overrides: Partial<Plan> = {}): Plan {
+  return {
+    id: 'plan-test-123',
+    objective: 'Implement authentication module',
+    scope: 'Auth only. Not including OAuth.',
+    status: 'executing',
+    decisions: [],
+    tasks: [
+      { id: 'task-1', title: 'Add auth middleware', description: 'Create auth middleware for Express', status: 'completed', updatedAt: Date.now() },
+      { id: 'task-2', title: 'Add login endpoint', description: 'POST /auth/login endpoint', status: 'completed', updatedAt: Date.now() },
+      { id: 'task-3', title: 'Add JWT utils', description: 'JWT signing and verification utilities', status: 'pending', updatedAt: Date.now() },
+    ],
+    checks: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+function makeTask(overrides: Partial<PlanTask> = {}): PlanTask {
+  return {
+    id: 'task-1',
+    title: 'Fix auth bug',
+    description: 'Fix the authentication timeout bug',
+    status: 'completed',
+    updatedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('collectGitEvidence', () => {
+  it('returns report with matched task evidence', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n') // git rev-parse
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nA\tsrc/auth/login.ts\nM\tsrc/auth/jwt.ts\n'); // git diff
+
+    const plan = makePlan();
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.planId).toBe('plan-test-123');
+    expect(report.planObjective).toBe('Implement authentication module');
+    expect(report.evidenceSources).toEqual(['git']);
+    expect(report.taskEvidence).toHaveLength(3);
+  });
+
+  it('marks tasks as DONE when status is completed and files match', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nA\tsrc/auth/login.ts\n');
+
+    const plan = makePlan();
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    const middlewareTask = report.taskEvidence.find((te) => te.taskId === 'task-1');
+    expect(middlewareTask?.verdict).toBe('DONE');
+  });
+
+  it('marks tasks as MISSING when no files match', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/unrelated/file.ts\n');
+
+    const plan = makePlan();
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    // All tasks should be MISSING since "unrelated" doesn't match any task keywords
+    const missing = report.taskEvidence.filter((te) => te.verdict === 'MISSING');
+    expect(missing.length).toBeGreaterThan(0);
+  });
+
+  it('marks skipped tasks as SKIPPED', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add auth middleware', description: 'Auth middleware', status: 'skipped', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence[0].verdict).toBe('SKIPPED');
+  });
+
+  it('identifies unplanned changes', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nM\tsrc/config/database.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add auth middleware', description: 'Auth middleware', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.unplannedChanges.length).toBeGreaterThanOrEqual(1);
+    const configChange = report.unplannedChanges.find((uc) => uc.file.path === 'src/config/database.ts');
+    expect(configChange).toBeDefined();
+    expect(configChange?.possibleReason).toBe('configuration change');
+  });
+
+  it('calculates accuracy score', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nA\tsrc/auth/login.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add auth middleware', description: 'Auth middleware', status: 'completed', updatedAt: Date.now() },
+        { id: 'task-2', title: 'Add login endpoint', description: 'Login endpoint', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.accuracy).toBeGreaterThanOrEqual(0);
+    expect(report.accuracy).toBeLessThanOrEqual(100);
+  });
+
+  it('returns 100% accuracy for empty task list', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('main\n')
+      .mockReturnValueOnce('');
+
+    const plan = makePlan({ tasks: [] });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.accuracy).toBe(100);
+  });
+
+  it('handles git failures gracefully', () => {
+    mockExecFileSync.mockImplementation(() => {
+      throw new Error('Not a git repository');
+    });
+
+    const plan = makePlan();
+    const report = collectGitEvidence(plan, '/not-a-repo', 'main');
+
+    expect(report.taskEvidence).toHaveLength(3);
+    expect(report.taskEvidence.every((te) => te.verdict === 'MISSING')).toBe(true);
+    expect(report.unplannedChanges).toHaveLength(0);
+  });
+
+  it('falls back to HEAD~5 when branch diff fails', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n') // rev-parse
+      .mockImplementationOnce(() => { throw new Error('bad revision'); }) // main...HEAD fails
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n'); // HEAD~5 fallback
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add auth middleware', description: 'Auth middleware', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence).toHaveLength(1);
+    expect(report.taskEvidence[0].verdict).toBe('DONE');
+  });
+
+  it('uses HEAD~10 when on the base branch', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('main\n') // on main branch
+      .mockReturnValueOnce('A\tsrc/auth/login.ts\n'); // diff HEAD~10
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add login endpoint', description: 'Login endpoint', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    collectGitEvidence(plan, '/project', 'main');
+
+    // Second call should use HEAD~10, not main...HEAD
+    const diffCall = mockExecFileSync.mock.calls[1];
+    const diffArgs = diffCall[1] as string[];
+    expect(diffArgs.some((arg: string) => arg.includes('HEAD~10'))).toBe(true);
+  });
+
+  it('parses renamed files correctly', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('R100\tsrc/old-auth.ts\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Add auth middleware', description: 'Auth middleware', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    // Should use the new path (after tab) for matching
+    const task = report.taskEvidence[0];
+    expect(task.matchedFiles.length).toBeGreaterThanOrEqual(1);
+    expect(task.matchedFiles[0].status).toBe('renamed');
+  });
+
+  it('parses deleted files', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('D\tsrc/auth/old-middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        { id: 'task-1', title: 'Remove old auth middleware', description: 'Delete old auth middleware files', status: 'completed', updatedAt: Date.now() },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    const task = report.taskEvidence[0];
+    if (task.matchedFiles.length > 0) {
+      expect(task.matchedFiles[0].status).toBe('deleted');
+    }
+  });
+
+  it('builds a human-readable summary', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan();
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.summary).toContain('/');
+    expect(report.summary).toContain('tasks verified by git evidence');
+  });
+
+  it('infers reasons for unplanned changes', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce(
+        'M\tpackage.json\n' +
+        'M\tsrc/types/auth.d.ts\n' +
+        'A\tsrc/tests/auth.test.ts\n' +
+        'M\tREADME.md\n' +
+        'M\tsrc/index.ts\n' +
+        'M\tsrc/random/file.ts\n'
+      );
+
+    const plan = makePlan({ tasks: [] });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    const reasons = report.unplannedChanges.map((uc) => uc.possibleReason);
+    expect(reasons).toContain('dependency update');
+    expect(reasons).toContain('type definition update');
+    expect(reasons).toContain('test file');
+    expect(reasons).toContain('documentation');
+    expect(reasons).toContain('likely re-export update');
+    expect(reasons).toContain('unplanned scope');
+  });
+});
+
+describe('collectVerificationGaps', () => {
+  it('returns empty array when no tasks have verification', () => {
+    const tasks: PlanTask[] = [makeTask()];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/auth.ts', status: 'modified' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('flags unproven findings on tasks that modify existing code', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        verification: {
+          findings: [
+            { description: 'Auth timeout under load', severity: 'high', proven: false },
+          ],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/auth.ts', status: 'modified' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(1);
+    expect(gaps[0].message).toContain('Unproven finding');
+    expect(gaps[0].message).toContain('Auth timeout under load');
+  });
+
+  it('does not flag proven findings', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        verification: {
+          findings: [
+            { description: 'Auth timeout under load', severity: 'high', proven: true, proof: 'Reproduced with load test' },
+          ],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/auth.ts', status: 'modified' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('does not flag tasks that only add new files', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        verification: {
+          findings: [
+            { description: 'Some finding', severity: 'medium', proven: false },
+          ],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/new-auth.ts', status: 'added' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('does not flag tasks with no evidence', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        verification: {
+          findings: [
+            { description: 'Some finding', severity: 'medium', proven: false },
+          ],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = []; // no evidence at all
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(0);
+  });
+
+  it('flags multiple unproven findings on the same task', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        verification: {
+          findings: [
+            { description: 'Finding A', severity: 'high', proven: false },
+            { description: 'Finding B', severity: 'medium', proven: false },
+            { description: 'Finding C', severity: 'low', proven: true },
+          ],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/auth.ts', status: 'modified' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(2);
+    expect(gaps[0].message).toContain('Finding A');
+    expect(gaps[1].message).toContain('Finding B');
+  });
+
+  it('handles tasks across multiple task IDs', () => {
+    const tasks: PlanTask[] = [
+      makeTask({
+        id: 'task-1',
+        verification: {
+          findings: [{ description: 'Bug A', severity: 'high', proven: false }],
+        },
+      }),
+      makeTask({
+        id: 'task-2',
+        title: 'Fix other bug',
+        verification: {
+          findings: [{ description: 'Bug B', severity: 'medium', proven: false }],
+        },
+      }),
+    ];
+    const evidence: GitTaskEvidence[] = [
+      { taskId: 'task-1', taskTitle: 'Fix auth bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/auth.ts', status: 'modified' }], verdict: 'DONE' },
+      { taskId: 'task-2', taskTitle: 'Fix other bug', plannedStatus: 'completed', matchedFiles: [{ path: 'src/other.ts', status: 'modified' }], verdict: 'DONE' },
+    ];
+
+    const gaps = collectVerificationGaps(tasks, evidence);
+    expect(gaps).toHaveLength(2);
+    expect(gaps[0].taskId).toBe('task-1');
+    expect(gaps[1].taskId).toBe('task-2');
+  });
+});

package/src/planning/evidence-collector.ts

@@ -26,6 +26,12 @@ export interface UnplannedChange {
   possibleReason: string;
 }
 
+export interface VerificationGap {
+  taskId: string;
+  taskTitle: string;
+  message: string;
+}
+
 export interface EvidenceReport {
   planId: string;
   planObjective: string;
@@ -34,6 +40,8 @@ export interface EvidenceReport {
   taskEvidence: GitTaskEvidence[];
   unplannedChanges: UnplannedChange[];
   missingWork: GitTaskEvidence[];
+  /** Advisory gaps for tasks claiming fixes without proven findings. */
+  verificationGaps: VerificationGap[];
   summary: string;
 }
 
@@ -93,6 +101,8 @@ export function collectGitEvidence(
     unplannedChanges.length,
   );
 
+  const verificationGaps = collectVerificationGaps(plan.tasks, taskEvidence);
+
   return {
     planId: plan.id,
     planObjective: plan.objective,
@@ -101,10 +111,50 @@ export function collectGitEvidence(
     taskEvidence,
     unplannedChanges,
     missingWork,
+    verificationGaps,
     summary,
   };
 }
 
+/**
+ * Flag tasks that modify existing code but lack proven verification findings.
+ * Advisory only — generates warnings, never blocks.
+ */
+export function collectVerificationGaps(
+  tasks: PlanTask[],
+  evidence: GitTaskEvidence[],
+): VerificationGap[] {
+  const gaps: VerificationGap[] = [];
+
+  for (const task of tasks) {
+    if (!taskModifiesExistingCode(task, evidence)) continue;
+    if (!task.verification) continue; // no verification field = no claim = no gap
+
+    const unproven = task.verification.findings.filter((f) => !f.proven);
+    for (const finding of unproven) {
+      gaps.push({
+        taskId: task.id,
+        taskTitle: task.title,
+        message: `Unproven finding: "${finding.description}" (${finding.severity}). Prove reproducible before fixing.`,
+      });
+    }
+  }
+
+  return gaps;
+}
+
+/**
+ * Check if a task modifies existing code (vs. creating new files).
+ */
+function taskModifiesExistingCode(
+  task: PlanTask,
+  evidence: GitTaskEvidence[],
+): boolean {
+  const taskEvidence = evidence.find((e) => e.taskId === task.id);
+  if (!taskEvidence) return false;
+  return taskEvidence.matchedFiles.some((f) => f.status === 'modified');
+}
+
 function getGitDiff(projectPath: string, baseBranch: string): FileChange[] {
   try {
     const currentBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {