synergyspec-selfevolving 1.3.0 → 2.0.0

package/dist/core/self-evolution/scope-gate.js

@@ -0,0 +1,107 @@
+/**
+ * 范围⊆诊断 scope⊆diagnosis gate for the 演进智能体 EVOLVING AGENT — loop v2
+ * (self-evolution as in-context RL).
+ *
+ * The 奖励智能体 REWARD AGENT names a set of GAPS, each anchored to a (file,
+ * section) the 文本梯度 textual gradient points at. The EVOLVING AGENT's ONE
+ * bounded edit must stay INSIDE those named sections — it may not wander off
+ * and rewrite an unrelated heading just because the file is editable. This gate
+ * is the check: from the line diff, compute each changed range's ENCLOSING
+ * section, and PASS iff every (file, section) the edit touches is covered by
+ * some diagnosis gap.
+ *
+ * Section addressing:
+ *   - `.md` files: the nearest PRECEDING markdown heading of any `#`-level
+ *     (`# …`, `## …`, …). A change before the first heading has section `''`
+ *     (the file preamble).
+ *   - YAML / other files: the nearest preceding TOP-LEVEL key (`key:` at column
+ *     0). A change before the first top-level key has section `''`.
+ *
+ * Coverage:
+ *   - a gap `{file: '*'}` covers ANY file;
+ *   - a gap `{section: '*'}` covers the WHOLE file;
+ *   - otherwise the gap's `file` AND `section` must match exactly.
+ *
+ * Pure + dependency-free (golden-testable). Re-uses {@link lineDiff} so its
+ * notion of "changed lines" is identical to the ≤ L budget check.
+ */
+import { lineDiff } from './line-diff.js';
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+/**
+ * The enclosing section of 1-based `line` in `proposedContent`. For `.md`
+ * files it is the nearest preceding heading's text; otherwise the nearest
+ * preceding top-level (`key:` at column 0) key. `''` when nothing precedes it.
+ */
+function enclosingSection(relPath, proposedLines, line) {
+    const isMarkdown = /\.md$/i.test(relPath);
+    let section = '';
+    // Scan from the file top down to (and including) the changed line; the last
+    // matching anchor at-or-before it is the enclosing section.
+    const upto = Math.min(line, proposedLines.length);
+    for (let idx = 0; idx < upto; idx++) {
+        const text = proposedLines[idx];
+        if (isMarkdown) {
+            const h = /^#{1,6}\s+(.+?)\s*$/.exec(text);
+            if (h)
+                section = h[1];
+        }
+        else {
+            // Top-level key: an identifier-ish key at column 0 followed by ':'.
+            const k = /^([^\s:#][^:]*):(?:\s|$)/.exec(text);
+            if (k)
+                section = k[1].trim();
+        }
+    }
+    return section;
+}
+/** True iff some gap covers `(file, section)` per the wildcard rules. */
+function isCovered(file, section, gaps) {
+    for (const gap of gaps) {
+        const fileOk = gap.file === '*' || toPosix(gap.file) === file;
+        if (!fileOk)
+            continue;
+        if (gap.section === '*' || gap.section === section)
+            return true;
+    }
+    return false;
+}
+/**
+ * Run the 范围⊆诊断 scope⊆diagnosis gate. For every edit, diff it against its
+ * current content, resolve each changed range's enclosing section, and flag any
+ * (file, section) not covered by a gap. Returns `{pass, violations}`; a pure
+ * deletion (no inserted range) is in-scope by construction (it removes named or
+ * unnamed lines but introduces no new out-of-scope section) and is not flagged.
+ */
+export function checkScopeWithinDiagnosis(input) {
+    const currentByPath = new Map(input.currentFiles.map((f) => [toPosix(f.relPath), f.content]));
+    // Accumulate violations keyed by file+section so the lines coalesce per spot.
+    const violationByKey = new Map();
+    for (const edit of input.edits) {
+        const rel = toPosix(edit.relPath);
+        const current = currentByPath.get(rel) ?? '';
+        const proposedLines = edit.content.length === 0 ? [] : edit.content.replace(/\n$/, '').split('\n');
+        const d = lineDiff(current, edit.content);
+        for (const range of d.changedRanges) {
+            const section = enclosingSection(rel, proposedLines, range.startLine);
+            if (isCovered(rel, section, input.gaps))
+                continue;
+            const key = `${rel}
${section}`;
+            const existing = violationByKey.get(key);
+            if (existing) {
+                existing.lines.push({ startLine: range.startLine, endLine: range.endLine });
+            }
+            else {
+                violationByKey.set(key, {
+                    file: rel,
+                    section,
+                    lines: [{ startLine: range.startLine, endLine: range.endLine }],
+                });
+            }
+        }
+    }
+    const violations = [...violationByKey.values()];
+    return { pass: violations.length === 0, violations };
+}
+//# sourceMappingURL=scope-gate.js.map

package/dist/core/self-evolution/success-channel.d.ts

@@ -0,0 +1,79 @@
+import type { LearnReport } from '../learn.js';
+export declare const PROTECTIONS_FILE = "protections.json";
+/** One protected surface: a section of a canonical target implicated in green runs. */
+export interface TargetProtection {
+    /** Producing canonical target id (e.g. `artifact-template:design`). */
+    targetId: string;
+    /** Design-section heading the credit path resolved, or `'*'` for the whole target. */
+    section: string;
+    /** Unique change names whose verified-green runs implicated this section. */
+    sourceChanges: string[];
+    /** Count of verified-green runs (mining calls) that implicated this section. */
+    occurrences: number;
+    /** ISO-8601 timestamp of the most recent implicating run. */
+    lastObservedAt: string;
+}
+export interface MineSuccessSignalsResult {
+    /** True iff the report was verified-GREEN and the channel ran. */
+    mined: boolean;
+    /** Protections recorded/incremented this call (0 when not green or persist failed). */
+    protectionsWritten: number;
+    /** Absolute paths of exemplar files written this call. */
+    exemplarsWritten: string[];
+    /** Target ids that received a protection this call (for one-line summaries). */
+    protectedTargets: string[];
+}
+/**
+ * The success-channel "green" predicate. DELIBERATELY the same predicate shape
+ * as the observed-verified gate conditions in `promote.ts` `isEvidenceComplete`
+ * (trajectoryFacts.verified === true AND observedStatus === 'success' OR
+ * observedPassRate >= 1) — read that function first when changing this one, so
+ * success-mining and the gate can never disagree about what "green" means.
+ */
+export declare function isVerifiedGreen(report: LearnReport): boolean;
+/**
+ * Read the persisted protections for one canonical target. Defensive read —
+ * absent/corrupt file means "no protections yet", never an error.
+ */
+export declare function readProtections(projectRoot: string, targetId: string): Promise<TargetProtection[]>;
+/**
+ * Exemplar file paths for a target, most-recent first (mtime desc, then
+ * filename desc as the deterministic tiebreak — the same order the retention
+ * cap uses). `[]` when the dir is absent.
+ */
+export declare function listExemplarFiles(projectRoot: string, targetId: string): Promise<string[]>;
+/**
+ * Parse the ✅-status rows of the spec-tests.md Requirement Traceability
+ * Matrix and return their Test Case files. Only rows INSIDE the
+ * `## Requirement Traceability Matrix` section count (the PBT Coverage table
+ * shares the pipe/✅ shape but its test column is scenario-level). The status
+ * cell is located by content (contains '✅') and the Test Case cell is the one
+ * just before it, so benign column drift does not blank the channel.
+ */
+export declare function passingTestFilesFromMatrix(specTestsMd: string): string[];
+/**
+ * Render the bounded DO-NOT-PRUNE block: one line per protected section with
+ * its passing-run count, plus the exemplar file paths. Empty string when there
+ * is nothing to protect. Deterministic: sorted by occurrences desc, then
+ * targetId/section.
+ */
+export declare function renderDoNotPruneBlock(protections: TargetProtection[], exemplarPaths: string[]): string;
+/**
+ * Mine a verified-GREEN learn report for protections + exemplars.
+ *
+ * NOT green ⇒ `{ mined: false }` and NOTHING is written — the success channel
+ * must never manufacture signal from an unverified or failing run (the exact
+ * inverse discipline of the observed-verified promote gate).
+ *
+ * Green ⇒ walk each ✅ matrix row's test back through the credit path
+ * (test → UC → task → design section), protect the producing target's section,
+ * persist merged protections, and write bounded real-excerpt exemplars
+ * (3 most-recent kept per target).
+ */
+export declare function mineSuccessSignals(opts: {
+    projectRoot: string;
+    report: LearnReport;
+    /** Injectable clock for tests; defaults to the wall clock. */
+    now?: () => Date;
+}): Promise<MineSuccessSignalsResult>;
+//# sourceMappingURL=success-channel.d.ts.map

package/dist/core/self-evolution/success-channel.js

@@ -0,0 +1,361 @@
+/**
+ * SUCCESS CHANNEL (R4: "the fence is the feature").
+ *
+ * The failure path mines red runs for corrective evolution hints; this module
+ * is its mirror: a verified-GREEN run is mined for (a) load-bearing
+ * PROTECTIONS — the design sections / tasks the passing tests' credit paths
+ * implicate as producers of working behavior — and (b) EXEMPLARS — bounded
+ * REAL excerpts of those artifacts. Both flow into the proposer surfaces as
+ * DO-NOT-PRUNE constraints, so an evolution candidate can never "improve" a
+ * template by hollowing out the parts that demonstrably produce green runs.
+ *
+ * Crucially this is a SIDE-WRITE channel only: a clean run still NEVER authors
+ * or triggers a corrective candidate (abstain-on-success is preserved — the
+ * channel writes protections/exemplars, never anything under `candidates/`).
+ *
+ * Persistence (best-effort, mirroring `health-baseline.ts`): a missing/corrupt
+ * protections file reads as empty, and a failed write never fails the learn
+ * run that triggered the mining.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { walkCreditPath } from '../learn/credit-path.js';
+import { producingTargetIdForCreditPath } from './learn-observation-adapter.js';
+export const PROTECTIONS_FILE = 'protections.json';
+/**
+ * The success-channel "green" predicate. DELIBERATELY the same predicate shape
+ * as the observed-verified gate conditions in `promote.ts` `isEvidenceComplete`
+ * (trajectoryFacts.verified === true AND observedStatus === 'success' OR
+ * observedPassRate >= 1) — read that function first when changing this one, so
+ * success-mining and the gate can never disagree about what "green" means.
+ */
+export function isVerifiedGreen(report) {
+    const facts = report.fitnessSample?.trajectoryFacts;
+    if (!facts || facts.verified !== true)
+        return false;
+    const greenByStatus = facts.observedStatus === 'success';
+    const greenByPassRate = typeof facts.observedPassRate === 'number' && facts.observedPassRate >= 1;
+    return greenByStatus || greenByPassRate;
+}
+function selfEvolutionDir(projectRoot) {
+    return path.join(path.resolve(projectRoot), '.synergyspec-selfevolving', 'self-evolution');
+}
+function protectionsPath(projectRoot) {
+    return path.join(selfEvolutionDir(projectRoot), PROTECTIONS_FILE);
+}
+/** Exemplar dir for a target — `:` is not portable in dir names, so `__`. */
+function exemplarDir(projectRoot, targetId) {
+    return path.join(selfEvolutionDir(projectRoot), 'exemplars', targetId.replace(/:/g, '__'));
+}
+async function readFileOrUndefined(abs) {
+    try {
+        return await fs.readFile(abs, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function isValidProtection(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const p = value;
+    return (typeof p.targetId === 'string' &&
+        typeof p.section === 'string' &&
+        Array.isArray(p.sourceChanges) &&
+        p.sourceChanges.every((c) => typeof c === 'string') &&
+        typeof p.occurrences === 'number' &&
+        Number.isFinite(p.occurrences) &&
+        typeof p.lastObservedAt === 'string');
+}
+/** Read ALL persisted protections; `[]` when the file is absent/unparseable. */
+async function readAllProtections(projectRoot) {
+    const raw = await readFileOrUndefined(protectionsPath(projectRoot));
+    if (raw === undefined)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return [];
+    const list = parsed.protections;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter(isValidProtection);
+}
+/**
+ * Read the persisted protections for one canonical target. Defensive read —
+ * absent/corrupt file means "no protections yet", never an error.
+ */
+export async function readProtections(projectRoot, targetId) {
+    return (await readAllProtections(projectRoot)).filter((p) => p.targetId === targetId);
+}
+/**
+ * Exemplar file paths for a target, most-recent first (mtime desc, then
+ * filename desc as the deterministic tiebreak — the same order the retention
+ * cap uses). `[]` when the dir is absent.
+ */
+export async function listExemplarFiles(projectRoot, targetId) {
+    const dir = exemplarDir(projectRoot, targetId);
+    let names;
+    try {
+        names = (await fs.readdir(dir)).filter((n) => n.endsWith('.md'));
+    }
+    catch {
+        return [];
+    }
+    const stats = [];
+    for (const name of names) {
+        const abs = path.join(dir, name);
+        try {
+            const st = await fs.stat(abs);
+            stats.push({ abs, name, mtimeMs: st.mtimeMs });
+        }
+        catch {
+            // raced deletion — skip
+        }
+    }
+    stats.sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
+    return stats.map((s) => s.abs);
+}
+/** Keep only the `keep` most-recent exemplar files in a target dir. */
+const EXEMPLARS_KEPT_PER_TARGET = 3;
+/** Per-excerpt caps for the exemplar substrate (real text, bounded). */
+const DESIGN_EXCERPT_CAP = 1500;
+const TASK_EXCERPT_CAP = 500;
+function capText(text, max) {
+    const t = text.trim();
+    return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+/**
+ * Parse the ✅-status rows of the spec-tests.md Requirement Traceability
+ * Matrix and return their Test Case files. Only rows INSIDE the
+ * `## Requirement Traceability Matrix` section count (the PBT Coverage table
+ * shares the pipe/✅ shape but its test column is scenario-level). The status
+ * cell is located by content (contains '✅') and the Test Case cell is the one
+ * just before it, so benign column drift does not blank the channel.
+ */
+export function passingTestFilesFromMatrix(specTestsMd) {
+    const lines = specTestsMd.split(/\r?\n/);
+    const files = [];
+    const seen = new Set();
+    let inMatrix = false;
+    for (const line of lines) {
+        const heading = line.match(/^(#{2,3})\s+(.+)$/);
+        if (heading) {
+            inMatrix = /requirement traceability matrix/i.test(heading[2]);
+            continue;
+        }
+        if (!inMatrix || !line.trimStart().startsWith('|'))
+            continue;
+        const cells = line.split('|').map((c) => c.trim());
+        const statusIdx = cells.findIndex((c) => c.includes('✅'));
+        if (statusIdx <= 0)
+            continue;
+        const testCell = cells[statusIdx - 1] ?? '';
+        for (const token of testCell.split(',')) {
+            // Strip backticks and a trailing `:line` suffix; keep only path-shaped tokens.
+            const file = token.replace(/`/g, '').trim().replace(/:\d+$/, '');
+            if (file.length === 0 || !/[\\/.]/.test(file))
+                continue;
+            if (seen.has(file))
+                continue;
+            seen.add(file);
+            files.push(file);
+        }
+    }
+    return files;
+}
+/** Render cap for the DO-NOT-PRUNE block fed into prompts / CLI output. */
+const DO_NOT_PRUNE_BLOCK_CAP = 1200;
+/** Short human label for a target id inside the rendered block. */
+function targetLabel(targetId) {
+    return targetId.startsWith('artifact-template:')
+        ? targetId.slice('artifact-template:'.length)
+        : targetId;
+}
+/**
+ * Render the bounded DO-NOT-PRUNE block: one line per protected section with
+ * its passing-run count, plus the exemplar file paths. Empty string when there
+ * is nothing to protect. Deterministic: sorted by occurrences desc, then
+ * targetId/section.
+ */
+export function renderDoNotPruneBlock(protections, exemplarPaths) {
+    if (protections.length === 0)
+        return '';
+    const sorted = [...protections].sort((a, b) => b.occurrences - a.occurrences ||
+        a.targetId.localeCompare(b.targetId) ||
+        a.section.localeCompare(b.section));
+    const lines = [];
+    for (const p of sorted) {
+        const where = p.section === '*' ? `${targetLabel(p.targetId)} (whole target)` : `${targetLabel(p.targetId)} §"${p.section}"`;
+        lines.push(`- ${where} — implicated in ${p.occurrences} passing run(s); do not delete or hollow out`);
+    }
+    if (exemplarPaths.length > 0) {
+        lines.push(`exemplars: ${exemplarPaths.join(', ')}`);
+    }
+    const block = lines.join('\n');
+    return block.length > DO_NOT_PRUNE_BLOCK_CAP
+        ? `${block.slice(0, DO_NOT_PRUNE_BLOCK_CAP - 1)}…`
+        : block;
+}
+/**
+ * Mine a verified-GREEN learn report for protections + exemplars.
+ *
+ * NOT green ⇒ `{ mined: false }` and NOTHING is written — the success channel
+ * must never manufacture signal from an unverified or failing run (the exact
+ * inverse discipline of the observed-verified promote gate).
+ *
+ * Green ⇒ walk each ✅ matrix row's test back through the credit path
+ * (test → UC → task → design section), protect the producing target's section,
+ * persist merged protections, and write bounded real-excerpt exemplars
+ * (3 most-recent kept per target).
+ */
+export async function mineSuccessSignals(opts) {
+    const { projectRoot, report } = opts;
+    if (!isVerifiedGreen(report)) {
+        return { mined: false, protectionsWritten: 0, exemplarsWritten: [], protectedTargets: [] };
+    }
+    const nowIso = (opts.now ? opts.now() : new Date()).toISOString();
+    // Read the change's artifacts straight from the change dir (tolerate absence:
+    // a missing artifact just truncates the walk, same as the failure path).
+    const specTestsMd = await readFileOrUndefined(path.join(report.changeDir, 'spec-tests.md'));
+    const tasksMd = await readFileOrUndefined(path.join(report.changeDir, 'tasks.md'));
+    const designMd = await readFileOrUndefined(path.join(report.changeDir, 'design.md'));
+    // Walk every passing test's credit path to its producing target + section.
+    const walkedPaths = [];
+    const minedKeys = new Map();
+    const protect = (targetId, section) => {
+        const key = `${targetId} ${section}`;
+        if (!minedKeys.has(key))
+            minedKeys.set(key, { targetId, section });
+    };
+    if (specTestsMd) {
+        for (const testFile of passingTestFilesFromMatrix(specTestsMd)) {
+            const creditPath = walkCreditPath({ testId: testFile, specTestsMd, tasksMd, designMd });
+            const targetId = producingTargetIdForCreditPath(creditPath);
+            if (!targetId)
+                continue;
+            walkedPaths.push(creditPath);
+            const designNode = creditPath.nodes.find((n) => n.kind === 'design-section');
+            // The design heading is the protected SECTION; a path that ended at a
+            // task protects the whole tasks template (no finer address exists).
+            protect(targetId, designNode ? designNode.id : '*');
+        }
+    }
+    // Whole-target protections: a green run whose tasks were ≥80% UC-mapped
+    // demonstrates the design/tasks templates produced a traceable, working
+    // decomposition — protect them as wholes even without per-test paths.
+    if (report.artifacts.taskProgress.mappingRatio >= 0.8) {
+        if (designMd !== undefined)
+            protect('artifact-template:design', '*');
+        if (tasksMd !== undefined)
+            protect('artifact-template:tasks', '*');
+    }
+    const mined = [...minedKeys.values()];
+    if (mined.length === 0) {
+        return { mined: true, protectionsWritten: 0, exemplarsWritten: [], protectedTargets: [] };
+    }
+    // MERGE with the persisted file: dedupe by targetId+section, increment
+    // occurrences once per mining call, track source changes uniquely.
+    const existing = await readAllProtections(projectRoot);
+    for (const m of mined) {
+        const found = existing.find((p) => p.targetId === m.targetId && p.section === m.section);
+        if (found) {
+            found.occurrences += 1;
+            if (!found.sourceChanges.includes(report.changeName)) {
+                found.sourceChanges.push(report.changeName);
+            }
+            found.lastObservedAt = nowIso;
+        }
+        else {
+            existing.push({
+                targetId: m.targetId,
+                section: m.section,
+                sourceChanges: [report.changeName],
+                occurrences: 1,
+                lastObservedAt: nowIso,
+            });
+        }
+    }
+    // Best-effort persist (health-baseline.ts pattern): a failed side-write must
+    // never fail the learn/episode run that triggered the mining.
+    let protectionsWritten = 0;
+    try {
+        const file = protectionsPath(projectRoot);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const payload = { version: 1, protections: existing };
+        await fs.writeFile(file, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+        protectionsWritten = mined.length;
+    }
+    catch {
+        // swallowed: side-write only
+    }
+    // EXEMPLARS: per protected target, persist the REAL excerpts the walked
+    // paths carried (the substrate the proposer's EXEMPLARS block quotes).
+    const exemplarsWritten = [];
+    const protectedTargets = [...new Set(mined.map((m) => m.targetId))];
+    const loss = report.fitnessSample?.loss?.loss;
+    for (const targetId of protectedTargets) {
+        const sections = [];
+        const seenExcerpts = new Set();
+        const pushExcerpt = (label, text, cap) => {
+            if (!text)
+                return;
+            const capped = capText(text, cap);
+            if (capped.length === 0 || seenExcerpts.has(capped))
+                return;
+            seenExcerpts.add(capped);
+            sections.push(`## ${label}\n\n${capped}`);
+        };
+        if (targetId === 'artifact-template:design') {
+            for (const p of walkedPaths) {
+                const design = p.nodes.find((n) => n.kind === 'design-section');
+                if (design)
+                    pushExcerpt(`design §"${design.id}"`, design.excerpt, DESIGN_EXCERPT_CAP);
+            }
+            // One task block for context: the first walked path's task hop.
+            const task = walkedPaths.flatMap((p) => p.nodes).find((n) => n.kind === 'task');
+            if (task)
+                pushExcerpt(`task ${task.id}`, task.excerpt, TASK_EXCERPT_CAP);
+        }
+        else if (targetId === 'artifact-template:tasks') {
+            for (const p of walkedPaths) {
+                const task = p.nodes.find((n) => n.kind === 'task');
+                if (task)
+                    pushExcerpt(`task ${task.id}`, task.excerpt, TASK_EXCERPT_CAP);
+            }
+        }
+        if (sections.length === 0)
+            continue;
+        const header = [
+            `# Exemplar: ${report.changeName}`,
+            '',
+            `- recorded: ${nowIso}`,
+            `- loss: ${typeof loss === 'number' ? loss.toFixed(3) : 'unmeasured'}`,
+            '',
+        ].join('\n');
+        const dir = exemplarDir(projectRoot, targetId);
+        const file = path.join(dir, `${report.changeName}.md`);
+        try {
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(file, `${header}\n${sections.join('\n\n')}\n`, 'utf8');
+            exemplarsWritten.push(file);
+            // Retention: keep only the 3 most-recent exemplar files per target
+            // (mtime desc with filename-desc tiebreak — deterministic even when a
+            // fast filesystem stamps identical mtimes).
+            const all = await listExemplarFiles(projectRoot, targetId);
+            for (const stale of all.slice(EXEMPLARS_KEPT_PER_TARGET)) {
+                await fs.rm(stale, { force: true });
+            }
+        }
+        catch {
+            // swallowed: side-write only
+        }
+    }
+    return { mined: true, protectionsWritten, exemplarsWritten, protectedTargets };
+}
+//# sourceMappingURL=success-channel.js.map

package/dist/core/self-evolution/target-evolution.d.ts

@@ -24,6 +24,15 @@ export interface TargetEvolutionPolicy {
     default: 'frozen' | 'evolvable';
     /** Per-target overrides: targetId -> evolve. */
     explicit: Map<string, boolean>;
+    /**
+     * The evolution-focus switch (config `selfEvolution.focus`, default ON;
+     * `learn --no-focus` turns it off per-run). When ON and the policy is
+     * frozen-by-default with explicit evolvable targets, learn re-aims a change's
+     * otherwise-dropped frozen-kind signals at those targets as a synthesized
+     * `origin: 'policy-focus'` hint instead of silently dropping them. Optional
+     * so hand-built policy literals stay valid; absent ⇒ enabled.
+     */
+    focusEnabled?: boolean;
     /** Provenance, for diagnostics / a future `status` view. */
     source: {
         config: boolean;
@@ -45,6 +54,8 @@ export declare function resolveTargetEvolutionPolicy(input: {
     config?: ProjectConfig | null;
     evolveTarget?: string;
     freezeTarget?: string;
+    /** CLI focus override (`learn --no-focus` ⇒ false). Beats config when set. */
+    focus?: boolean;
 }): TargetEvolutionPolicy;
 /**
  * The single decision used by every enforcement point. Does NOT account for the

package/dist/core/self-evolution/target-evolution.js

@@ -45,6 +45,8 @@ export function resolveTargetEvolutionPolicy(input) {
     return {
         default: dflt,
         explicit,
+        // CLI override (--no-focus) > config selfEvolution.focus > default ON.
+        focusEnabled: input.focus ?? se?.focus ?? true,
         source: { config: !!se, cliEvolve: input.evolveTarget, cliFreeze: input.freezeTarget },
     };
 }

package/dist/core/self-evolution/tool-evolution.js

@@ -189,12 +189,10 @@ export function classifyEvolvablePart(filePath) {
     if (!file)
         return [];
     const parts = [];
-    if (file === 'src/core/self-evolution/template-variants.ts' ||
-        file.startsWith('.synergyspec-selfevolving/self-evolution/templates/') ||
-        file.startsWith('.synergyspec-selfevolving/self-evolution/template-variants') ||
+    if (file.startsWith('.synergyspec-selfevolving/self-evolution/templates/') ||
         file.startsWith('schemas/') ||
         /\/templates\//.test(file)) {
-        parts.push('template-variants');
+        parts.push('artifact-templates');
     }
     if (file === 'src/core/self-evolution/archive-memory.ts') {
         parts.push('archive-memory');
@@ -212,15 +210,6 @@ export function classifyEvolvablePart(filePath) {
         file.startsWith('src/memory/extraction/')) {
         parts.push('runtime-memory');
     }
-    if (file.startsWith('evolve/src/evolution/') ||
-        file.startsWith('evolve/src/proposer/') ||
-        file.startsWith('evolve/src/mutators/') ||
-        file.startsWith('evolve/src/variant/') ||
-        file.startsWith('evolve/src/materialize/') ||
-        file.startsWith('evolve/src/benchmark/') ||
-        file === 'src/commands/evolve.ts') {
-        parts.push('dgm-harness');
-    }
     if (file === 'src/core/self-evolution/tool-evolution.ts' ||
         file.startsWith('evolve/src/safety/') ||
         file.startsWith('evolve/test/safety/')) {

package/dist/core/self-evolution/verdict.d.ts

@@ -9,12 +9,15 @@ export declare const VERDICT_FILE = "verdict.json";
  *  - `gate-failed`  — the static gate refused it.
  *  - `declined`     — an auto-promote predicate said no (non-terminal: the
  *                     candidate may still be retried later).
- *  - `outcompeted`  — lost the GA ranking to a sibling variant for the same
- *                     target (advisory; the candidate's status is untouched).
  */
-export type CandidateVerdictKind = 'promoted' | 'rolled-back' | 'rejected' | 'gate-failed' | 'declined' | 'outcompeted';
-/** Who/what reached the verdict — for provenance in the trajectory block. */
-export type CandidateVerdictDecider = 'human' | 'auto-evolve' | 'evolve-from-edits' | 'evolve-outer-loop' | 'static-gate';
+export type CandidateVerdictKind = 'promoted' | 'rolled-back' | 'rejected' | 'gate-failed' | 'declined';
+/**
+ * Who/what reached the verdict — for provenance in the trajectory block.
+ * Internal enum, not a user-facing capability. (Legacy verdict.json files may
+ * carry a now-removed `'auto-evolve'` decider; the unchecked cast on read keeps
+ * those readable.)
+ */
+export type CandidateVerdictDecider = 'human' | 'evolve-from-edits' | 'static-gate';
 export interface CandidateVerdictRecord {
     verdict: CandidateVerdictKind;
     /** ISO-8601 UTC timestamp the verdict was reached (caller-supplied). */

package/dist/core/self-evolution/verdict.js

@@ -2,11 +2,9 @@
  * Per-candidate promotion VERDICT (the backward-pass label the proposer reads).
  *
  * `fitness-record.jsonl` records HOW a candidate scored; this sidecar records
- * what the loop DECIDED about it — promoted, rejected, outcompeted, etc. — plus
- * the loss it carried at decision time and the baseline it was judged against.
- * The optimization-trajectory block ({@link import('./trajectory.js')}) renders
- * these labels so the proposer can learn from prior accepted/rejected attempts
- * (OPRO/AlphaEvolve: scored history of past solutions in the meta-prompt).
+ * what the loop DECIDED about it — promoted, rejected, etc. — plus the loss it
+ * carried at decision time and the baseline it was judged against, so the
+ * manual promote / evolve-from-edits path can learn from prior decisions.
  *
  * A candidate has exactly ONE current verdict, so this is a single JSON object
  * (last-write-wins), NOT an append-only log — the full transition history
@@ -37,8 +35,7 @@ function isValidVerdictKind(value) {
         value === 'rolled-back' ||
         value === 'rejected' ||
         value === 'gate-failed' ||
-        value === 'declined' ||
-        value === 'outcompeted');
+        value === 'declined');
 }
 /**
  * Write (or overwrite) a candidate's current verdict. Atomic tmp+rename inside

package/dist/core/templates/skill-templates.d.ts

@@ -23,4 +23,5 @@ export { getCiSkillTemplate, getOpsxCiCommandTemplate } from './workflows/ci.js'
 export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 export { getCompareImagesSkillTemplate } from './workflows/compare-images.js';
+export { getSelfEvolvingSkillTemplate } from './workflows/self-evolving.js';
 //# sourceMappingURL=skill-templates.d.ts.map