@soleri/core 9.9.0 → 9.11.0

package/src/runtime/claude-md-helpers.test.ts

@@ -12,6 +12,7 @@ import {
   composeIntegrationSection,
   buildInjectionContent,
   injectEngineRulesBlock,
+  removeEngineRulesFromGlobal,
 } from './claude-md-helpers.js';
 import type { AgentRuntimeConfig } from './types.js';
 
@@ -186,4 +187,84 @@ describe('injectEngineRulesBlock', () => {
     expect(result).toContain('AFTER');
     expect(result).toContain('REPLACED');
   });
+
+  it('handles empty content by appending rules', () => {
+    const result = injectEngineRulesBlock('', 'RULES');
+    expect(result).toContain('RULES');
+  });
+
+  it('is idempotent — double injection replaces cleanly', () => {
+    const first = injectEngineRulesBlock('# File', `${RULES_START}\nV1\n${RULES_END}`);
+    const second = injectEngineRulesBlock(first, `${RULES_START}\nV2\n${RULES_END}`);
+    expect(second).toContain('V2');
+    expect(second).not.toContain('V1');
+    // Should have exactly one start marker
+    const startCount = (second.match(/<!-- soleri:engine-rules -->/g) || []).length;
+    expect(startCount).toBe(1);
+  });
+});
+
+describe('removeEngineRulesFromGlobal', () => {
+  const RULES_START = '<!-- soleri:engine-rules -->';
+  const RULES_END = '<!-- /soleri:engine-rules -->';
+
+  it('returns unchanged content when no engine rules present', () => {
+    const content = '# Global CLAUDE.md\n\nSome user content.';
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(false);
+    expect(cleaned).toBe(content);
+  });
+
+  it('removes engine rules block from content', () => {
+    const content = `# Global\n\n${RULES_START}\nEngine rules here\n${RULES_END}\n\nUser content`;
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(true);
+    expect(cleaned).not.toContain('Engine rules here');
+    expect(cleaned).not.toContain(RULES_START);
+    expect(cleaned).not.toContain(RULES_END);
+    expect(cleaned).toContain('# Global');
+    expect(cleaned).toContain('User content');
+  });
+
+  it('handles engine rules at end of file', () => {
+    const content = `# Global\n\n${RULES_START}\nRules\n${RULES_END}`;
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(true);
+    expect(cleaned).toContain('# Global');
+    expect(cleaned).not.toContain('Rules');
+  });
+
+  it('handles engine rules at start of file', () => {
+    const content = `${RULES_START}\nRules\n${RULES_END}\n\n# Global`;
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(true);
+    expect(cleaned).toContain('# Global');
+    expect(cleaned).not.toContain(RULES_START);
+  });
+
+  it('preserves agent blocks when removing engine rules', () => {
+    const content = [
+      '# Global',
+      '',
+      '<!-- agent:mybot:mode -->',
+      'Agent content',
+      '<!-- /agent:mybot:mode -->',
+      '',
+      RULES_START,
+      'Engine rules',
+      RULES_END,
+    ].join('\n');
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(true);
+    expect(cleaned).toContain('<!-- agent:mybot:mode -->');
+    expect(cleaned).toContain('Agent content');
+    expect(cleaned).not.toContain('Engine rules');
+  });
+
+  it('returns non-empty string for content that is only engine rules', () => {
+    const content = `${RULES_START}\nOnly rules\n${RULES_END}`;
+    const { cleaned, removed } = removeEngineRulesFromGlobal(content);
+    expect(removed).toBe(true);
+    expect(cleaned.length).toBeGreaterThan(0);
+  });
 });

package/src/runtime/claude-md-helpers.ts

@@ -216,3 +216,28 @@ export function injectEngineRulesBlock(content: string, engineRulesContent: stri
   // Append
   return content.trimEnd() + '\n\n' + engineRulesContent + '\n';
 }
+
+/**
+ * Remove engine rules block from content.
+ * Used during self-healing to strip engine rules from global CLAUDE.md
+ * when they were incorrectly injected there (they belong in _engine.md).
+ *
+ * Returns the content without the engine rules block, or unchanged if no block found.
+ */
+export function removeEngineRulesFromGlobal(content: string): {
+  cleaned: string;
+  removed: boolean;
+} {
+  if (!hasEngineRules(content)) {
+    return { cleaned: content, removed: false };
+  }
+
+  const startIdx = content.indexOf(ENGINE_RULES_START);
+  const endIdx = content.indexOf(ENGINE_RULES_END);
+
+  const before = content.slice(0, startIdx).trimEnd();
+  const after = content.slice(endIdx + ENGINE_RULES_END.length).trimStart();
+
+  const cleaned = before + (before && after ? '\n\n' : '') + after;
+  return { cleaned: cleaned || '\n', removed: true };
+}

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

@@ -151,7 +151,8 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       }),
       handler: async (params) => {
         const { resolve } = await import('node:path');
-        const projectPath = resolve((params.projectPath as string) ?? '.');
+        const { findProjectRoot } = await import('../../paths.js');
+        const projectPath = findProjectRoot(resolve((params.projectPath as string) ?? '.'));
         const summary = (params.summary ?? params.conversationContext) as string;
         if (!summary) {
           return { captured: false, error: 'Either summary or conversationContext is required.' };

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

@@ -363,10 +363,10 @@ describe('createOrchestrateOps', () => {
         outcome: 'completed',
       })) as Record<string, unknown>;
 
-      // Should complete successfully without evidenceReport
+      // Should complete successfully with evidenceReport: null
       expect(result).toHaveProperty('plan');
       expect(result).toHaveProperty('session');
-      expect(result).not.toHaveProperty('evidenceReport');
+      expect(result.evidenceReport).toBeNull();
     });
 
     it('adds warning when evidence accuracy is below 50%', async () => {
@@ -395,6 +395,55 @@ describe('createOrchestrateOps', () => {
       const warnings = result.warnings as string[];
       expect(warnings.some((w) => w.includes('Low evidence accuracy (30%)'))).toBe(true);
     });
+
+    it('runs evidence collection for abandoned plans too', async () => {
+      const { collectGitEvidence } = await import('../planning/evidence-collector.js');
+      vi.mocked(collectGitEvidence).mockReturnValueOnce({
+        planId: 'plan-1',
+        planObjective: 'test',
+        accuracy: 60,
+        evidenceSources: ['git'],
+        taskEvidence: [
+          {
+            taskId: 't1',
+            taskTitle: 'Task 1',
+            plannedStatus: 'pending',
+            matchedFiles: [],
+            verdict: 'MISSING',
+          },
+        ],
+        unplannedChanges: [],
+        missingWork: [],
+        verificationGaps: [],
+        summary: '0/1 tasks verified by git evidence',
+      });
+
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        planId: 'plan-1',
+        sessionId: 'session-1',
+        outcome: 'abandoned',
+        projectPath: '.',
+      })) as Record<string, unknown>;
+
+      expect(collectGitEvidence).toHaveBeenCalled();
+      expect(result).toHaveProperty('evidenceReport');
+      const report = result.evidenceReport as Record<string, unknown>;
+      expect(report.accuracy).toBe(60);
+      expect(Array.isArray(report.taskEvidence)).toBe(true);
+    });
+
+    it('returns evidenceReport as null when no plan is provided', async () => {
+      const op = findOp(ops, 'orchestrate_complete');
+      const result = (await op.handler({
+        sessionId: 'session-1',
+        outcome: 'completed',
+        summary: 'Direct task without a plan',
+      })) as Record<string, unknown>;
+
+      expect(result).toHaveProperty('evidenceReport');
+      expect(result.evidenceReport).toBeNull();
+    });
   });
 
   // ─── orchestrate_status ───────────────────────────────────────

package/src/runtime/orchestrate-ops.ts

@@ -43,7 +43,11 @@ 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';
+import {
+  analyzeQualitySignals,
+  captureQualitySignals,
+  buildFixTrailSummary,
+} from './quality-signals.js';
 
 // ---------------------------------------------------------------------------
 // Intent detection — keyword-based mapping from prompt to intent
@@ -832,7 +836,7 @@ export function createOrchestrateOps(
 
         // Evidence-based reconciliation: cross-reference plan tasks against git diff
         let evidenceReport: EvidenceReport | null = null;
-        if (planObj && outcome === 'completed') {
+        if (planObj) {
           try {
             evidenceReport = collectGitEvidence(
               planObj,
@@ -840,6 +844,9 @@ export function createOrchestrateOps(
               'main',
             );
             if (evidenceReport.accuracy < 50) {
+              console.error(
+                `[soleri] Evidence accuracy ${evidenceReport.accuracy}% — significant drift detected between plan and git state`,
+              );
               warnings.push(
                 `Low evidence accuracy (${evidenceReport.accuracy}%) — plan tasks may not match git changes.`,
               );
@@ -873,6 +880,7 @@ export function createOrchestrateOps(
         }
 
         // End brain session — runs regardless of plan existence
+        const fixTrail = evidenceReport ? buildFixTrailSummary(evidenceReport) : undefined;
         const session = brainIntelligence.lifecycle({
           action: 'end',
           sessionId,
@@ -880,6 +888,7 @@ export function createOrchestrateOps(
           planOutcome: outcome,
           toolsUsed,
           filesModified,
+          ...(fixTrail ? { context: `Fix trail: ${fixTrail}` } : {}),
         });
 
         // Record brain feedback for vault entries referenced in plan decisions
@@ -974,7 +983,7 @@ export function createOrchestrateOps(
           extraction,
           epilogue: epilogueResult,
           ...(impactReport ? { impactAnalysis: impactReport } : {}),
-          ...(evidenceReport ? { evidenceReport } : {}),
+          evidenceReport,
           ...(warnings.length > 0 ? { warnings } : {}),
         };
       },

package/src/runtime/quality-signals.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { analyzeQualitySignals, captureQualitySignals } from './quality-signals.js';
+import {
+  analyzeQualitySignals,
+  captureQualitySignals,
+  buildFixTrailSummary,
+} from './quality-signals.js';
 import type { EvidenceReport } from '../planning/evidence-collector.js';
 
 // ---------------------------------------------------------------------------
@@ -104,7 +108,7 @@ describe('analyzeQualitySignals', () => {
     expect(result.antiPatterns).toHaveLength(0);
   });
 
-  it('does not flag task with fixIterations === 2 (at threshold, not above)', () => {
+  it('flags task with fixIterations === 2 (at threshold)', () => {
     const report = makeReport({
       taskEvidence: [
         {
@@ -120,7 +124,28 @@ describe('analyzeQualitySignals', () => {
 
     const result = analyzeQualitySignals(report);
 
+    expect(result.antiPatterns).toHaveLength(1);
+    expect(result.antiPatterns[0].fixIterations).toBe(2);
+  });
+
+  it('does not flag task with fixIterations === 1 (below threshold)', () => {
+    const report = makeReport({
+      taskEvidence: [
+        {
+          taskId: 't4b',
+          taskTitle: 'Single retry task',
+          plannedStatus: 'completed',
+          matchedFiles: [],
+          verdict: 'DONE',
+          fixIterations: 1,
+        },
+      ],
+    });
+
+    const result = analyzeQualitySignals(report);
+
     expect(result.antiPatterns).toHaveLength(0);
+    expect(result.cleanTasks).toHaveLength(0);
   });
 
   it('detects scope creep from unplanned changes', () => {
@@ -199,9 +224,14 @@ describe('captureQualitySignals', () => {
     expect(entry.tags).toContain('auto-captured');
 
     expect(brain.recordFeedback).toHaveBeenCalledWith(
-      'quality-signal:rework:Fix login',
-      't1',
-      'dismissed',
+      expect.objectContaining({
+        query: 'Fix login',
+        entryId: 'plan-1',
+        action: 'dismissed',
+        confidence: 0.7,
+        source: 'evidence-quality',
+        reason: 'Task needed 3 fix iterations — high rework',
+      }),
     );
 
     expect(result.captured).toBe(1);
@@ -226,9 +256,14 @@ describe('captureQualitySignals', () => {
     const result = captureQualitySignals(analysis, vault, brain, 'plan-1');
 
     expect(brain.recordFeedback).toHaveBeenCalledWith(
-      'quality-signal:clean:Add feature',
-      't2',
-      'accepted',
+      expect.objectContaining({
+        query: 'Add feature',
+        entryId: 'plan-1',
+        action: 'accepted',
+        confidence: 0.9,
+        source: 'evidence-quality',
+        reason: 'Clean first-try completion — no rework needed',
+      }),
     );
     expect(result.feedback).toBe(1);
     expect(result.captured).toBe(0);
@@ -281,6 +316,83 @@ describe('captureQualitySignals', () => {
     expect(entry.severity).toBe('critical');
   });
 
+  it('records positive feedback with evidence-quality source for clean first-try tasks', () => {
+    const analysis = {
+      antiPatterns: [],
+      cleanTasks: [
+        {
+          taskId: 'clean-1',
+          taskTitle: 'Smooth task',
+          kind: 'clean' as const,
+          fixIterations: 0,
+          verdict: 'DONE',
+        },
+      ],
+      scopeCreep: [],
+    };
+
+    captureQualitySignals(analysis, vault, brain, 'plan-99');
+
+    expect(brain.recordFeedback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: 'accepted',
+        confidence: 0.9,
+        source: 'evidence-quality',
+        entryId: 'plan-99',
+      }),
+    );
+  });
+
+  it('records negative feedback with evidence-quality source for high-rework tasks', () => {
+    const analysis = {
+      antiPatterns: [
+        {
+          taskId: 'rework-1',
+          taskTitle: 'Painful task',
+          kind: 'anti-pattern' as const,
+          fixIterations: 3,
+          verdict: 'DONE',
+        },
+      ],
+      cleanTasks: [],
+      scopeCreep: [],
+    };
+
+    captureQualitySignals(analysis, vault, brain, 'plan-99');
+
+    expect(brain.recordFeedback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: 'dismissed',
+        confidence: 0.7,
+        source: 'evidence-quality',
+        reason: 'Task needed 3 fix iterations — high rework',
+        context: JSON.stringify({ taskId: 'rework-1', reworkCount: 3, verdict: 'DONE' }),
+      }),
+    );
+  });
+
+  it('does not record evidence-quality feedback for tasks with 1 fix iteration', () => {
+    // 1 fix iteration = neither clean (fixIterations !== 0) nor anti-pattern (< 2)
+    const analysis = analyzeQualitySignals(
+      makeReport({
+        taskEvidence: [
+          {
+            taskId: 't-mid',
+            taskTitle: 'Single retry',
+            plannedStatus: 'completed',
+            matchedFiles: [],
+            verdict: 'DONE',
+            fixIterations: 1,
+          },
+        ],
+      }),
+    );
+
+    captureQualitySignals(analysis, vault, brain, 'plan-99');
+
+    expect(brain.recordFeedback).not.toHaveBeenCalled();
+  });
+
   it('handles mixed signals correctly', () => {
     const analysis = {
       antiPatterns: [
@@ -310,3 +422,65 @@ describe('captureQualitySignals', () => {
     expect(result.feedback).toBe(2); // 1 dismissed + 1 accepted
   });
 });
+
+// ---------------------------------------------------------------------------
+// buildFixTrailSummary
+// ---------------------------------------------------------------------------
+
+describe('buildFixTrailSummary', () => {
+  it('returns summary string for tasks with rework iterations', () => {
+    const report = makeReport({
+      taskEvidence: [
+        {
+          taskId: 'a',
+          taskTitle: 'Task A',
+          plannedStatus: 'completed',
+          matchedFiles: [],
+          verdict: 'DONE',
+          fixIterations: 2,
+        },
+        {
+          taskId: 'b',
+          taskTitle: 'Task B',
+          plannedStatus: 'completed',
+          matchedFiles: [],
+          verdict: 'DONE',
+          fixIterations: 0,
+        },
+        {
+          taskId: 'c',
+          taskTitle: 'Task C',
+          plannedStatus: 'completed',
+          matchedFiles: [],
+          verdict: 'DONE',
+          fixIterations: 3,
+        },
+      ],
+    });
+
+    const summary = buildFixTrailSummary(report);
+    expect(summary).toBe('Task A: 2 fix iterations; Task C: 3 fix iterations');
+  });
+
+  it('returns undefined when no tasks have rework', () => {
+    const report = makeReport({
+      taskEvidence: [
+        {
+          taskId: 'a',
+          taskTitle: 'Clean',
+          plannedStatus: 'completed',
+          matchedFiles: [],
+          verdict: 'DONE',
+          fixIterations: 0,
+        },
+      ],
+    });
+
+    expect(buildFixTrailSummary(report)).toBeUndefined();
+  });
+
+  it('returns undefined for empty task evidence', () => {
+    const report = makeReport({ taskEvidence: [] });
+    expect(buildFixTrailSummary(report)).toBeUndefined();
+  });
+});

package/src/runtime/quality-signals.ts

@@ -34,8 +34,12 @@ export interface QualityAnalysis {
 // Thresholds
 // ---------------------------------------------------------------------------
 
-/** Tasks with more than this many fix iterations are flagged as anti-patterns. */
+/** Tasks with this many or more fix iterations are flagged as anti-patterns. */
 const REWORK_THRESHOLD = 2;
+/** Brain feedback confidence for clean first-try tasks. */
+const CLEAN_TASK_CONFIDENCE = 0.9;
+/** Brain feedback confidence for high-rework anti-pattern tasks. */
+const REWORK_TASK_CONFIDENCE = 0.7;
 
 // ---------------------------------------------------------------------------
 // Analysis
@@ -44,7 +48,7 @@ const REWORK_THRESHOLD = 2;
 /**
  * Analyze an evidence report for quality signals.
  *
- * - fixIterations > 2 → anti-pattern (rework)
+ * - fixIterations >= 2 → anti-pattern (rework)
  * - fixIterations === 0 + verdict DONE → clean (first-pass success)
  * - unplannedChanges → scope-creep signals
  */
@@ -59,7 +63,7 @@ export function analyzeQualitySignals(
   for (const te of report.taskEvidence) {
     const iterations = te.fixIterations ?? 0;
 
-    if (iterations > REWORK_THRESHOLD) {
+    if (iterations >= REWORK_THRESHOLD) {
       antiPatterns.push({
         taskId: te.taskId,
         taskTitle: te.taskTitle,
@@ -148,7 +152,19 @@ export function captureQualitySignals(
   // Record negative brain feedback for rework tasks
   for (const ap of analysis.antiPatterns) {
     try {
-      brain.recordFeedback(`quality-signal:rework:${ap.taskTitle}`, ap.taskId, 'dismissed');
+      brain.recordFeedback({
+        query: ap.taskTitle,
+        entryId: planId,
+        action: 'dismissed',
+        confidence: REWORK_TASK_CONFIDENCE,
+        source: 'evidence-quality',
+        reason: `Task needed ${ap.fixIterations} fix iterations — high rework`,
+        context: JSON.stringify({
+          taskId: ap.taskId,
+          reworkCount: ap.fixIterations,
+          verdict: ap.verdict,
+        }),
+      });
       feedback++;
     } catch {
       // Best-effort
@@ -158,7 +174,14 @@ export function captureQualitySignals(
   // Record positive brain feedback for clean tasks
   for (const ct of analysis.cleanTasks) {
     try {
-      brain.recordFeedback(`quality-signal:clean:${ct.taskTitle}`, ct.taskId, 'accepted');
+      brain.recordFeedback({
+        query: ct.taskTitle,
+        entryId: planId,
+        action: 'accepted',
+        confidence: CLEAN_TASK_CONFIDENCE,
+        source: 'evidence-quality',
+        reason: 'Clean first-try completion — no rework needed',
+      });
       feedback++;
     } catch {
       // Best-effort
@@ -167,3 +190,19 @@ export function captureQualitySignals(
 
   return { captured, skipped, feedback };
 }
+
+// ---------------------------------------------------------------------------
+// Fix-trail summary for knowledge extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a human-readable fix-trail summary from an evidence report.
+ * Returns `undefined` when no tasks had rework iterations.
+ */
+export function buildFixTrailSummary(report: EvidenceReport): string | undefined {
+  const entries = report.taskEvidence
+    .filter((te) => (te.fixIterations ?? 0) > 0)
+    .map((te) => `${te.taskTitle}: ${te.fixIterations} fix iterations`);
+
+  return entries.length > 0 ? entries.join('; ') : undefined;
+}