synergyspec-selfevolving 2.1.5 → 2.1.6

package/dist/core/fitness/test-metrics.js

@@ -41,6 +41,32 @@ function allPassedReportSummary(line) {
         return null;
     return Number(passed[1]);
 }
+function aggregateMetrics(items) {
+    const totals = items.reduce((acc, item) => ({
+        total: acc.total + item.total,
+        passed: acc.passed + item.passed,
+        failed: acc.failed + item.failed,
+    }), { total: 0, passed: 0, failed: 0 });
+    return {
+        ...totals,
+        passRate: rate(totals.passed, totals.total),
+    };
+}
+function synergySpecReportSummary(line) {
+    const summary = /^Summary:\s*\d+\s+collected,\s*(\d+)\s+passed,\s*(\d+)\s+failed(?:,\s*\d+\s+skipped)?(?:,\s*(\d+)\s+collection\s+errors?)?\.?$/i.exec(line);
+    if (!summary)
+        return null;
+    const passed = Number(summary[1]);
+    const failed = Number(summary[2]);
+    const collectionErrors = summary[3] !== undefined ? Number(summary[3]) : 0;
+    const total = passed + failed + collectionErrors;
+    return {
+        total,
+        passed,
+        failed: failed + collectionErrors,
+        passRate: rate(passed, total),
+    };
+}
 /**
  * Extract pass/fail counts from test-runner summary text. Recognizes the
  * canonical runner summary shapes and takes the LAST one (runners print the
@@ -50,6 +76,7 @@ function allPassedReportSummary(line) {
  *              "1 failed, 9 passed in 0.4s"         (order-independent)
  *   - SynergySpec reports: table/status prose like
  *              "Passed; 85 tests collected and passed"
+ *              "Summary: 29 collected, 29 passed, 0 failed, 0 skipped, 0 collection errors."
  * A bare "N passed" line that is not a recognized summary (e.g. prose or a
  * per-suite tally) is ignored. Pytest "errors" count toward `failed`.
  * Returns null when no recognized summary is found.
@@ -59,8 +86,18 @@ export function parseTestMetrics(reportText) {
         return null;
     const text = reportText.replace(ANSI_SGR, '');
     let result = null;
+    let authoritativeSummary = null;
+    const pytestSummaries = [];
+    let nonPytestSummarySeen = false;
     for (const raw of text.split(/\r?\n/)) {
         const line = raw.trim();
+        const synergySpecSummary = synergySpecReportSummary(line);
+        if (synergySpecSummary !== null) {
+            result = synergySpecSummary;
+            authoritativeSummary = synergySpecSummary;
+            nonPytestSummarySeen = true;
+            continue;
+        }
         const passed = count(line, /(\d+)\s+passed\b/i);
         if (passed === null) {
             const reportPassed = allPassedReportSummary(line);
@@ -71,6 +108,7 @@ export function parseTestMetrics(reportText) {
                     failed: 0,
                     passRate: rate(reportPassed, reportPassed),
                 };
+                nonPytestSummarySeen = true;
             }
             continue;
         }
@@ -86,6 +124,17 @@ export function parseTestMetrics(reportText) {
             continue;
         const total = passed + failed + errored;
         result = { total, passed, failed: failed + errored, passRate: rate(passed, total) };
+        if (/\bin\s+[\d.]+\s*m?s\b/i.test(line)) {
+            pytestSummaries.push(result);
+        }
+        else {
+            nonPytestSummarySeen = true;
+        }
+    }
+    if (authoritativeSummary)
+        return authoritativeSummary;
+    if (pytestSummaries.length > 1 && !nonPytestSummarySeen) {
+        return aggregateMetrics(pytestSummaries);
     }
     return result;
 }

package/dist/core/learn.js

@@ -8,10 +8,11 @@ import { parseTasksMarkdown } from './self-evolution/task-quality.js';
 import { buildLLMSummaryCandidates, } from './learn/llm-summary.js';
 import { parseTestMetrics, computePerChangeLoss, measureHealthReport, resolveMetricSource, } from './fitness/index.js';
 import { readProjectConfig } from './project-config.js';
-import { getTrajectoryForChange } from './trajectory/registry.js';
-import { toTrajectoryFacts, extractExpectedTestPaths } from './trajectory/facts.js';
+import { getTrajectoryResultForChange } from './trajectory/registry.js';
+import { toTrajectoryFacts, extractExpectedTestPaths, } from './trajectory/facts.js';
 import { toActionSkeleton, renderActionSkeleton } from './trajectory/skeleton.js';
 import { walkCreditPath } from './learn/credit-path.js';
+import { readRunnerEvidenceResultFromTestReport, runnerEvidenceToTrajectoryFacts, } from './runner-evidence.js';
 const PRIMARY_ARTIFACTS = [
     ['proposal', 'proposal.md'],
     ['usecases', 'usecases.md'],
@@ -51,7 +52,19 @@ export async function generateLearnReport(args = {}) {
     // that is absent or `stub` the source returns no signal, `measureHealthPenalty`
     // yields null, and the loss is byte-identical to the functional-only baseline.
     const testReport = artifacts.evidence.find((f) => /(?:^|[\\/])(?:test-report|run-tests?-report|ci-report)\.md$/i.test(f.relativePath));
-    const testMetrics = testReport ? parseTestMetrics(testReport.content) : null;
+    const specTestsForScope = artifacts.evidence.find((f) => /(?:^|[\\/])spec-tests\.md$/i.test(f.relativePath));
+    const expectedTestPaths = extractExpectedTestPaths(specTestsForScope?.content);
+    const runnerEvidenceResult = testReport
+        ? await readRunnerEvidenceResultFromTestReport({
+            projectRoot,
+            changeName: resolved.changeName,
+            changeDir: resolved.changeDir,
+            testReportContent: testReport.content,
+        })
+        : { evidence: null };
+    const runnerEvidence = runnerEvidenceResult.evidence;
+    const reportTestMetrics = testReport ? parseTestMetrics(testReport.content) : null;
+    const testMetrics = runnerEvidence?.testMetrics ?? reportTestMetrics;
     let healthPenalty;
     let healthSourceName;
     let healthContributors = [];
@@ -71,23 +84,71 @@ export async function generateLearnReport(args = {}) {
     // than trusting the hand-authored test-report. `getTrajectoryForChange`
     // returns null when nothing is discoverable, so on the artifact-only path
     // `trajectoryFacts` is null and the fitness output is byte-identical baseline.
-    const trajectory = args.trajectorySource
-        ? await args.trajectorySource.getTrajectory(resolved.changeName).catch(() => null)
-        : await getTrajectoryForChange(projectRoot, resolved.changeName);
+    let trajectoryMiss = null;
+    let trajectory;
+    if (args.trajectorySource) {
+        try {
+            if (args.trajectorySource.getTrajectoryResult) {
+                const trajectoryResult = await args.trajectorySource.getTrajectoryResult(resolved.changeName);
+                trajectory = trajectoryResult.trajectory;
+                if (!trajectory) {
+                    trajectoryMiss = {
+                        reason: trajectoryResult.reason ?? 'adapter-returned-null',
+                        sourceHarness: args.trajectorySource.harness ?? null,
+                    };
+                }
+            }
+            else {
+                trajectory = await args.trajectorySource.getTrajectory(resolved.changeName);
+            }
+        }
+        catch (err) {
+            trajectory = null;
+            trajectoryMiss = {
+                reason: err instanceof Error ? err.message : String(err),
+                sourceHarness: args.trajectorySource.harness ?? null,
+            };
+        }
+    }
+    else {
+        const trajectoryResult = await getTrajectoryResultForChange(projectRoot, resolved.changeName);
+        trajectory = trajectoryResult.trajectory;
+        if (!trajectory) {
+            trajectoryMiss = {
+                reason: trajectoryResult.reason ?? 'adapter-returned-null',
+                sourceHarness: trajectoryResult.sourceHarness,
+            };
+        }
+    }
     // Change-scope guard input: the change's own expected test paths (from its
     // spec-tests.md mapping). Lets toTrajectoryFacts DEMOTE a green-but-irrelevant
     // run (a default `pytest` that collected ZERO of the change's tests) to
     // unverified so the 奖励智能体 REWARD AGENT abstains instead of certifying a
     // false-GREEN. Absent/empty ⇒ no gate (byte-identical baseline).
-    const specTestsForScope = artifacts.evidence.find((f) => /(?:^|[\\/])spec-tests\.md$/i.test(f.relativePath));
-    const expectedTestPaths = extractExpectedTestPaths(specTestsForScope?.content);
-    const trajectoryFacts = toTrajectoryFacts(trajectory, resolved.changeName, {
+    const rawTrajectoryFacts = toTrajectoryFacts(trajectory, resolved.changeName, {
         expectedTestPaths,
     });
+    const runnerEvidenceFacts = runnerEvidence
+        ? runnerEvidenceToTrajectoryFacts({
+            evidence: runnerEvidence,
+            changeName: resolved.changeName,
+            expectedTestPaths,
+        })
+        : null;
+    const runnerTrajectoryConflict = runnerEvidenceFacts?.verified === true &&
+        rawTrajectoryFacts?.verified === true &&
+        factsDisagree(runnerEvidenceFacts, rawTrajectoryFacts);
+    const trajectoryFacts = runnerEvidenceFacts?.verified === true
+        ? runnerEvidenceFacts
+        : (!rawTrajectoryFacts ||
+            !rawTrajectoryFacts.testRunObserved ||
+            (rawTrajectoryFacts.observedStatus === null && rawTrajectoryFacts.observedPassRate === null)) &&
+            runnerEvidenceFacts
+            ? runnerEvidenceFacts
+            : rawTrajectoryFacts;
     // "Trust the trajectory": when a real runner was observed, its pass rate wins
     // over the authored test-report; otherwise the report stands but is flagged
-    // unverified (observe-only soft penalty — `unverifiedWeight` defaults to 0, so
-    // the loss is unchanged until a maintainer raises it).
+    // unverified and receives the default soft penalty.
     const observedPassRate = trajectoryFacts?.testRunObserved && trajectoryFacts.observedPassRate !== null
         ? trajectoryFacts.observedPassRate
         : null;
@@ -217,6 +278,54 @@ export async function generateLearnReport(args = {}) {
             });
         }
     }
+    if (runnerTrajectoryConflict && runnerEvidenceFacts && rawTrajectoryFacts) {
+        observations.push({
+            code: 'runner-trajectory-conflict',
+            summary: 'Durable runner-exit evidence disagrees with the host trajectory; runner-exit.json is the graded functional source.',
+            evidence: [
+                ...runnerEvidenceFacts.sourcePaths.slice(0, 2).map((file) => ({
+                    file,
+                    detail: `runner evidence status=${runnerEvidenceFacts.observedStatus ?? 'unknown'} passRate=${runnerEvidenceFacts.observedPassRate ?? 'n/a'}`,
+                })),
+                ...rawTrajectoryFacts.sourcePaths.slice(0, 2).map((file) => ({
+                    file,
+                    detail: `trajectory status=${rawTrajectoryFacts.observedStatus ?? 'unknown'} passRate=${rawTrajectoryFacts.observedPassRate ?? 'n/a'}`,
+                })),
+            ],
+            tags: ['runner-evidence', 'trajectory', 'conflict', 'fitness'],
+            severity: 'action',
+        });
+    }
+    if (!rawTrajectoryFacts && trajectoryMiss !== null) {
+        observations.push({
+            code: 'trajectory-source-miss',
+            summary: `No observed host trajectory was available (${trajectoryMiss.reason}).`,
+            evidence: [
+                {
+                    file: relativePath(projectRoot, resolved.changeDir),
+                    detail: `sourceHarness=${trajectoryMiss.sourceHarness ?? 'unresolved'}; reason=${trajectoryMiss.reason}`,
+                },
+            ],
+            tags: ['trajectory', 'unverified', 'fitness'],
+            severity: runnerEvidenceFacts?.verified === true ? 'info' : 'action',
+        });
+    }
+    if (runnerEvidenceResult.reason &&
+        runnerEvidenceResult.exitJsonPath &&
+        runnerEvidenceFacts?.verified !== true) {
+        observations.push({
+            code: 'runner-evidence-miss',
+            summary: `Runner evidence was present but could not be used (${runnerEvidenceResult.reason}).`,
+            evidence: [
+                {
+                    file: relativePath(projectRoot, runnerEvidenceResult.exitJsonPath),
+                    detail: runnerEvidenceResult.reason,
+                },
+            ],
+            tags: ['runner-evidence', 'unverified', 'fitness'],
+            severity: trajectoryFacts?.verified === true ? 'info' : 'action',
+        });
+    }
     // Health head is CONFIGURED (a non-stub source was selected) but produced NO
     // signal: surface it loudly rather than letting the health half of the loss
     // silently default to 0. Default-on health must never fail invisibly — this
@@ -335,6 +444,15 @@ function buildLearnObservations(report) {
     }
     return observations;
 }
+function factsDisagree(left, right) {
+    if (left.observedStatus !== right.observedStatus)
+        return true;
+    const leftRate = left.observedPassRate;
+    const rightRate = right.observedPassRate;
+    if (leftRate === null || rightRate === null)
+        return leftRate !== rightRate;
+    return Math.abs(leftRate - rightRate) > 0.000001;
+}
 export async function applyLearnCandidates(args) {
     return applyLearnMemoryCandidates({
         projectRoot: args.projectRoot,

package/dist/core/migration.d.ts

@@ -11,22 +11,14 @@ import type { AIToolOption } from './config.js';
  */
 export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[]): string[];
 /**
- * No-op: a custom profile's workflow list is the user's deliberate choice.
+ * One-time compatibility upgrade for v2.1.5.
  *
- * Previously this function appended every entry from ALL_WORKFLOWS to the
- * user's custom workflow list so that newly-shipped workflows would
- * auto-enable. That defeats the contract — "custom means custom". A user
- * who wants every workflow picks `profile: 'all'`; a user on `profile:
- * 'custom'` is intentionally limiting their setup, and auto-appending
- * silently invalidates that choice.
+ * Most custom profiles are deliberate and must stay untouched. The exception
+ * is an exact snapshot of every built-in workflow from before Dream existed:
+ * that snapshot behaves like "all workflows" and should receive Dream once.
  *
- * Users who want to enable an additional workflow after a `synergyspec-selfevolving`
- * upgrade can do so explicitly via `synergyspec-selfevolving config`. Fix:
- * `fix-custom-profile-filtering` (2026-05-17).
- *
- * The function is kept (rather than deleted) so existing callers in
- * `init.ts` and `update.ts` continue to compile without coordinated
- * edits. A future cleanup change can remove all three at once.
+ * A migration marker prevents re-adding Dream if the user removes it after this
+ * backfill has already run.
  */
 export declare function upgradeCustomWorkflows(): void;
 /**

package/dist/core/migration.js

@@ -10,6 +10,26 @@ import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
 import { ALL_WORKFLOWS } from './profiles.js';
 import path from 'path';
 import * as fs from 'fs';
+const DREAM_WORKFLOW_BACKFILL_MARKER = 'dream-workflow-v2.1.5';
+const LEGACY_ALL_WORKFLOWS_BEFORE_DREAM = [
+    'propose',
+    'explore',
+    'new',
+    'continue',
+    'apply',
+    'tdd',
+    'ff',
+    'sync',
+    'archive',
+    'bulk-archive',
+    'verify',
+    'learn',
+    'verify-spec',
+    'onboard',
+    'gen-tests',
+    'run-tests',
+    'ci',
+];
 function scanInstalledWorkflowArtifacts(projectPath, tools) {
     const installed = new Set();
     let hasSkills = false;
@@ -62,26 +82,51 @@ function inferDelivery(artifacts) {
     }
     return 'skills';
 }
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function hasSameWorkflowSet(actual, expected) {
+    if (actual.length !== expected.length)
+        return false;
+    const actualSet = new Set(actual);
+    return expected.every((workflow) => actualSet.has(workflow));
+}
+function hasMigrationMarker(config, marker) {
+    return asStringArray(config.migrations).includes(marker);
+}
+function appendMigrationMarker(config, marker) {
+    const migrations = asStringArray(config.migrations);
+    if (!migrations.includes(marker)) {
+        config.migrations = [...migrations, marker];
+    }
+}
 /**
- * No-op: a custom profile's workflow list is the user's deliberate choice.
- *
- * Previously this function appended every entry from ALL_WORKFLOWS to the
- * user's custom workflow list so that newly-shipped workflows would
- * auto-enable. That defeats the contract — "custom means custom". A user
- * who wants every workflow picks `profile: 'all'`; a user on `profile:
- * 'custom'` is intentionally limiting their setup, and auto-appending
- * silently invalidates that choice.
+ * One-time compatibility upgrade for v2.1.5.
  *
- * Users who want to enable an additional workflow after a `synergyspec-selfevolving`
- * upgrade can do so explicitly via `synergyspec-selfevolving config`. Fix:
- * `fix-custom-profile-filtering` (2026-05-17).
+ * Most custom profiles are deliberate and must stay untouched. The exception
+ * is an exact snapshot of every built-in workflow from before Dream existed:
+ * that snapshot behaves like "all workflows" and should receive Dream once.
  *
- * The function is kept (rather than deleted) so existing callers in
- * `init.ts` and `update.ts` continue to compile without coordinated
- * edits. A future cleanup change can remove all three at once.
+ * A migration marker prevents re-adding Dream if the user removes it after this
+ * backfill has already run.
  */
 export function upgradeCustomWorkflows() {
-    // intentionally empty — see comment above.
+    const config = getGlobalConfig();
+    if (config.profile !== 'custom')
+        return;
+    if (hasMigrationMarker(config, DREAM_WORKFLOW_BACKFILL_MARKER))
+        return;
+    const workflows = asStringArray(config.workflows);
+    if (workflows.includes('dream')) {
+        appendMigrationMarker(config, DREAM_WORKFLOW_BACKFILL_MARKER);
+        saveGlobalConfig(config);
+        return;
+    }
+    if (!hasSameWorkflowSet(workflows, LEGACY_ALL_WORKFLOWS_BEFORE_DREAM))
+        return;
+    config.workflows = [...LEGACY_ALL_WORKFLOWS_BEFORE_DREAM, 'dream'];
+    appendMigrationMarker(config, DREAM_WORKFLOW_BACKFILL_MARKER);
+    saveGlobalConfig(config);
 }
 /**
  * Performs one-time migration if the global config does not yet have a profile field.
@@ -94,7 +139,7 @@ export function upgradeCustomWorkflows() {
  */
 export function migrateIfNeeded(projectPath, tools) {
     const config = getGlobalConfig();
-    // Check raw config file for profile field presence
+    // Check raw config file for profile field presence.
     const configPath = getGlobalConfigPath();
     let rawConfig = {};
     try {
@@ -103,20 +148,17 @@ export function migrateIfNeeded(projectPath, tools) {
         }
     }
     catch {
-        return; // Can't read config, skip migration
+        return;
     }
-    // If profile is already explicitly set, no migration needed
+    // If profile is already explicitly set, no migration needed.
     if (rawConfig.profile !== undefined) {
         return;
     }
-    // Scan for installed workflows
     const artifacts = scanInstalledWorkflowArtifacts(projectPath, tools);
     const installedWorkflows = artifacts.workflows;
     if (installedWorkflows.length === 0) {
-        // No workflows installed, new user — defaults will apply
         return;
     }
-    // Migrate: set profile to custom with detected workflows
     config.profile = 'custom';
     config.workflows = installedWorkflows;
     if (rawConfig.delivery === undefined) {

package/dist/core/runner-evidence.d.ts

@@ -0,0 +1,53 @@
+import { type TestMetrics } from './fitness/test-metrics.js';
+import type { TrajectoryFacts } from './trajectory/facts.js';
+export interface WorkspaceIdentityFileSnapshot {
+    path?: string;
+    name?: string;
+    sha256?: string;
+}
+export interface WorkspaceIdentitySnapshot {
+    cwd?: string;
+    changeName?: string;
+    taskId?: string;
+    pyproject?: WorkspaceIdentityFileSnapshot;
+    packageJson?: WorkspaceIdentityFileSnapshot;
+}
+export interface RunnerEvidence {
+    exitJsonPath: string;
+    command?: string;
+    stdoutLogPath?: string;
+    stderrLogPath?: string;
+    exitCode: number | null;
+    testMetrics: TestMetrics | null;
+    outputText: string;
+    sourcePaths: string[];
+    workspaceIdentity: {
+        verified: boolean;
+        reason?: string;
+        recorded?: WorkspaceIdentitySnapshot;
+        current: WorkspaceIdentitySnapshot;
+    };
+}
+export interface RunnerEvidenceLookupResult {
+    evidence: RunnerEvidence | null;
+    reason?: string;
+    exitJsonPath?: string;
+}
+export declare function readRunnerEvidenceFromTestReport(args: {
+    projectRoot: string;
+    changeName: string;
+    changeDir?: string;
+    testReportContent: string;
+}): Promise<RunnerEvidence | null>;
+export declare function readRunnerEvidenceResultFromTestReport(args: {
+    projectRoot: string;
+    changeName: string;
+    changeDir?: string;
+    testReportContent: string;
+}): Promise<RunnerEvidenceLookupResult>;
+export declare function runnerEvidenceToTrajectoryFacts(args: {
+    evidence: RunnerEvidence;
+    changeName: string;
+    expectedTestPaths?: string[];
+}): TrajectoryFacts | null;
+//# sourceMappingURL=runner-evidence.d.ts.map