synergyspec-selfevolving 1.3.0 → 2.0.0

package/dist/core/self-evolution/learn-observation-adapter.js

@@ -23,6 +23,8 @@ import { relativePath } from './shared.js';
 import { validateLearnEvolutionHint, } from './learn-hints.js';
 import { findCanonicalTargetsByFile, listCanonicalTargets, lookupCanonicalTarget, } from './canonical-targets.js';
 import { isCanonicalTargetEvolvable, explicitTargetIds, } from './target-evolution.js';
+import { renderCreditPath } from '../learn/credit-path.js';
+import { buildProposerSlice } from './proposer-slice.js';
 import { detectRepoMode, resolveTargetLocalFiles } from './local-targets.js';
 import { getSchemaDir } from '../artifact-graph/resolver.js';
 import { SKILL_NAMESPACES } from '../config.js';
@@ -126,6 +128,33 @@ export async function resolveTargetLocalFilesReadonly(targetId, repoRoot) {
     }
     return out;
 }
+/**
+ * The producing canonical target for a credit path's LAST resolved node.
+ * Static artifact→template map: a path that reached a design section was
+ * produced through the design template; one that stopped at a task, through
+ * the tasks template. Paths ending at `test`/`use-case` have no nameable
+ * producer (the usecases template is oracle-frozen and not a canonical
+ * target). When a policy is supplied and the resolved target is FROZEN, the
+ * target is still NAMED — annotated `[frozen]` — because the address is
+ * observational; policy gates candidates, not evidence text.
+ */
+const PRODUCING_TARGET_BY_LAST_NODE = {
+    'design-section': 'artifact-template:design',
+    task: 'artifact-template:tasks',
+};
+/** Raw producing-target id for a path's last node (no policy annotation). */
+export function producingTargetIdForCreditPath(creditPath) {
+    const last = creditPath.nodes[creditPath.nodes.length - 1];
+    return last ? PRODUCING_TARGET_BY_LAST_NODE[last.kind] : undefined;
+}
+function resolveProducingTarget(creditPath, policy) {
+    const targetId = producingTargetIdForCreditPath(creditPath);
+    if (!targetId)
+        return undefined;
+    if (policy && !isCanonicalTargetEvolvable(targetId, policy))
+        return `${targetId} [frozen]`;
+    return targetId;
+}
 /**
  * Derive structured evolution hints from a learn report's signals.
  *
@@ -215,13 +244,41 @@ export function generateEvolutionHints(report, policy) {
             });
         }
     }
-    // Heuristic (c): Failure evidence in verification artifacts → add-verification-step.
+    // Heuristic (c): Failure evidence → add-verification-step. Provenance is
+    // forwarded onto each evidence item: 'observed' items were re-sourced from
+    // the observed runner output (the source the gate trusts), 'authored' from
+    // the agent-written artifacts; absent = legacy/authored.
     if (report.artifacts.failureEvidence.length > 0) {
-        const evidence = uniqueByFile(report.artifacts.failureEvidence.map((item) => ({
+        const observedItems = report.artifacts.failureEvidence.filter((item) => item.source === 'observed');
+        // Dedup: authored items keep the legacy one-per-artifact-file rule
+        // (byte-identical baseline); observed items dedupe per failing TEST, so
+        // two failures in the same test file both survive.
+        const dedupSeen = new Set();
+        const evidence = report.artifacts.failureEvidence
+            .map((item) => ({
             file: toPosix(item.file),
             quoteOrSummary: limitText(item.line, 200),
             severity: 'high',
-        }))).slice(0, 6);
+            ...(item.source ? { provenance: item.source } : {}),
+            // The ADDRESS: the neutral credit path completed with the producing
+            // canonical target this layer (not learn) resolves. SUSPECT framing —
+            // recurrence across changes (the grouping machinery) is the confirmer.
+            ...(item.creditPath
+                ? { address: renderCreditPath(item.creditPath, resolveProducingTarget(item.creditPath, policy)) }
+                : {}),
+        }))
+            .filter((item) => {
+            const key = item.provenance === 'observed' ? `${item.file}::${item.quoteOrSummary}` : item.file;
+            if (dedupSeen.has(key))
+                return false;
+            dedupSeen.add(key);
+            return true;
+        })
+            .slice(0, 6);
+        const creditPaths = report.artifacts.failureEvidence
+            .map((item) => item.creditPath)
+            .filter((p) => p !== undefined)
+            .slice(0, 6);
         if (evidence.length > 0) {
             const proposedChangeType = 'add-verification-step';
             drafts.push({
@@ -229,13 +286,16 @@ export function generateEvolutionHints(report, policy) {
                 sourceChange: report.changeName,
                 affectedTargetKind: 'workflow-prompt',
                 proposedChangeType,
-                problem: limitText(`Verification evidence still contains ${report.artifacts.failureEvidence.length} failure-like line(s); the workflow may be missing a verification gate.`, 500),
+                problem: limitText(observedItems.length > 0
+                    ? `The observed test run recorded ${observedItems.length} failing test(s); the workflow may be missing a verification gate.`
+                    : `Verification evidence still contains ${report.artifacts.failureEvidence.length} failure-like line(s); the workflow may be missing a verification gate.`, 500),
                 evidence,
                 confidence: 'medium',
                 risk: 'high',
                 expectedBenefit: 'Add a verification step that catches the failure pattern before archive.',
                 evalNeeded: evalSuitesFor('workflow-prompt'),
                 thresholdKey: `workflow-prompt:unspecified:${proposedChangeType}`,
+                ...(creditPaths.length > 0 ? { creditPaths } : {}),
             });
         }
     }
@@ -263,6 +323,29 @@ export function generateEvolutionHints(report, policy) {
             });
         }
     }
+    // Health-contributor enrichment (observe-only): when the fitness sample
+    // names the worst per-file/per-function health offenders, append them as
+    // evidence onto the artifact-template drafts the heuristics ALREADY produced
+    // — code shape is a property of the generated implementation, whose producing
+    // surface is the artifact-template chain. Never creates a new hint or
+    // trigger: a clean run with offenders but no drafts stays abstained
+    // (abstain-on-success preserved), and workflow-prompt drafts are untouched.
+    const healthOffenders = report.fitnessSample?.healthContributors ?? [];
+    if (healthOffenders.length > 0) {
+        const offenderEvidence = healthOffenders
+            .slice(0, 3)
+            .map((offender) => ({
+            file: toPosix(offender.file),
+            quoteOrSummary: limitText(describeHealthOffender(offender), 200),
+            severity: 'medium',
+        }));
+        for (const draft of drafts) {
+            if (draft.affectedTargetKind !== 'artifact-template')
+                continue;
+            // Existing convention: each draft carries at most 6 evidence items.
+            draft.evidence = [...draft.evidence, ...offenderEvidence].slice(0, 6);
+        }
+    }
     // Backward-pass: stamp every hint from this change with the change's loss
     // (functional ⊕ health) so the accumulator/GA can select on fitness, not just
     // occurrence. Same value for all hints from one change; absent when no
@@ -277,7 +360,19 @@ export function generateEvolutionHints(report, policy) {
     // an evolvable target; when EXACTLY one is evolvable the hint is pinned to it
     // (e.g. a generic artifact-template hint becomes an `artifact-template:design`
     // hint when only design may evolve). Omitting `policy` skips scoping.
-    const scoped = scopeHintsByPolicy(drafts, policy);
+    const { kept: scoped, droppedFrozen } = scopeHintsByPolicy(drafts, policy);
+    // Evolution focus (ses_148b/1483/1488: design-only policy + workflow-kind-only
+    // signals ⇒ every draft silently dropped ⇒ "Target: none" on all three runs):
+    // when the policy is frozen-by-default with explicit evolvable targets and
+    // EVERY draft fell to the frozen filter, re-aim the dropped drafts' evidence
+    // at the focused target(s) as one synthesized low-confidence
+    // `origin: 'policy-focus'` hint each, instead of dropping the change's
+    // signals on the floor. Fires only on a zero-survivor scope (a surviving hint
+    // for the focused target is always the better vehicle) and is disabled by
+    // `selfEvolution.focus: false` / `learn --no-focus`.
+    if (scoped.length === 0 && droppedFrozen.length > 0) {
+        scoped.push(...buildPolicyFocusHints(report, droppedFrozen, policy, nextId));
+    }
     // Defensive: drop anything that fails the contract validator.
     const validHints = [];
     for (const draft of scoped) {
@@ -315,20 +410,30 @@ export function generateEvolutionHints(report, policy) {
  * targets, so no policy value can name them; a CLI-named id is pinned only when
  * it is a registered, same-kind target that is evolvable under the resolved
  * policy (so `--freeze-target` still wins).
+ *
+ * Returns the kept hints PLUS the drafts dropped by the frozen filter
+ * (`droppedFrozen`: a pinned hint whose target is frozen, or a kind-only hint
+ * whose kind has zero evolvable targets) — the evolution-focus pass re-aims
+ * their evidence instead of losing it silently.
  */
 function scopeHintsByPolicy(drafts, policy) {
     if (!policy)
-        return drafts;
+        return { kept: drafts, droppedFrozen: [] };
     const kept = [];
+    const droppedFrozen = [];
     for (const draft of drafts) {
         if (draft.affectedTargetId) {
             if (isCanonicalTargetEvolvable(draft.affectedTargetId, policy))
                 kept.push(draft);
+            else
+                droppedFrozen.push(draft);
             continue;
         }
         const pinId = resolveKindOnlyPinTarget(draft, policy);
-        if (pinId === null)
-            continue; // kind has no evolvable target → drop
+        if (pinId === null) {
+            droppedFrozen.push(draft); // kind has no evolvable target → drop
+            continue;
+        }
         if (pinId !== undefined) {
             kept.push({
                 ...draft,
@@ -341,7 +446,7 @@ function scopeHintsByPolicy(drafts, policy) {
         }
         kept.push(draft); // ambiguous → keep kind-only/unspecified
     }
-    return kept;
+    return { kept, droppedFrozen };
 }
 /**
  * Decide the concrete target a kind-only hint should be pinned to under the
@@ -367,6 +472,101 @@ export function resolveKindOnlyPinTarget(draft, policy) {
         return evolvable[0].id;
     return undefined;
 }
+/**
+ * The evolution-focus target ids: the explicitly evolvable, REGISTERED
+ * canonical targets of a frozen-by-default policy, with the focus switch ON.
+ *
+ * Empty (focus inactive) when:
+ * - the switch is off (`selfEvolution.focus: false` / `learn --no-focus`),
+ * - the policy default is `evolvable` (nothing is dropped as frozen-kind in the
+ *   way focus rescues — and "evolve everything" needs no focus), or
+ * - no explicit target survives (freeze-wins already resolved into `explicit`).
+ *
+ * Exported for the learn command's transparency rendering, so the printed focus
+ * line cannot drift from the hint-synthesis pass.
+ */
+export function resolveEvolutionFocusTargets(policy) {
+    if (!policy)
+        return [];
+    if (policy.focusEnabled === false)
+        return [];
+    if (policy.default !== 'frozen')
+        return [];
+    return [...policy.explicit.entries()]
+        .filter(([id, evolve]) => evolve && lookupCanonicalTarget(id) !== undefined)
+        .map(([id]) => id)
+        .sort((left, right) => left.localeCompare(right));
+}
+/**
+ * Synthesize the `origin: 'policy-focus'` hint(s) that re-aim a zero-survivor
+ * change's policy-dropped signals at the focused target(s).
+ *
+ * Honesty contract (SUSPECT framing, like credit-path addresses):
+ * - evidence is the UNION of the dropped drafts' REAL evidence items — nothing
+ *   is fabricated, and a change with no dropped signals gets no focus hint
+ *   ("Target: none" stays the correct evidence-gated abstention);
+ * - `confidence` is pinned to `low`: the causal link from the evidence to the
+ *   focused target is a hypothesis for the proposer to evaluate, not a finding;
+ * - the downstream gates are untouched — the focus hint only buys ENTRY into
+ *   propose/gate/evidence/loss, never promotion.
+ */
+function buildPolicyFocusHints(report, droppedFrozen, policy, nextId) {
+    const focusIds = resolveEvolutionFocusTargets(policy);
+    if (focusIds.length === 0)
+        return [];
+    // Union the dropped drafts' real evidence (dedup by file+quote, cap 6 — the
+    // existing per-hint evidence convention).
+    const evidence = [];
+    const seen = new Set();
+    for (const draft of droppedFrozen) {
+        for (const item of draft.evidence) {
+            const key = `${item.file}\u0000${item.quoteOrSummary}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            evidence.push(item);
+        }
+    }
+    const cappedEvidence = evidence.slice(0, 6);
+    if (cappedEvidence.length === 0)
+        return [];
+    // The strongest dropped intent labels the synthesized change type.
+    const droppedTypes = new Set(droppedFrozen.map((draft) => draft.proposedChangeType));
+    const proposedChangeType = droppedTypes.has('add-verification-step')
+        ? 'add-verification-step'
+        : droppedTypes.has('tighten-output-contract')
+            ? 'tighten-output-contract'
+            : 'clarify-instruction';
+    const frozenKinds = [...new Set(droppedFrozen.map((draft) => draft.affectedTargetKind))]
+        .sort()
+        .join(', ');
+    const changeLoss = report.fitnessSample?.loss?.loss;
+    return focusIds.flatMap((focusId) => {
+        const target = lookupCanonicalTarget(focusId);
+        if (!target)
+            return [];
+        const hint = {
+            id: nextId(`focus-${focusId}`),
+            sourceChange: report.changeName,
+            affectedTargetKind: target.kind,
+            affectedTargetId: focusId,
+            proposedChangeType,
+            problem: limitText(`Evolution focus: the policy evolves only ${focusIds.join(', ')}; ${droppedFrozen.length} learn signal(s) from this change bound to frozen kind(s) (${frozenKinds}) and would otherwise be dropped. Evaluate whether ${focusId} could be improved so these signals do not recur — the evidence is re-aimed (SUSPECT framing), not proof this target caused it.`, 500),
+            evidence: cappedEvidence,
+            confidence: 'low',
+            risk: 'medium',
+            expectedBenefit: limitText(`A focused improvement to ${focusId} grounded in this change's observed signals, instead of dropping them because their originating kind is frozen.`, 500),
+            evalNeeded: evalSuitesFor(target.kind),
+            // `focusId` is already a full `<kind>:<name>` target id, so the grouping
+            // key is `<id>:<changeType>` (no doubled kind prefix).
+            thresholdKey: `${focusId}:${proposedChangeType}`,
+            origin: 'policy-focus',
+        };
+        if (typeof changeLoss === 'number')
+            hint.loss = changeLoss;
+        return [hint];
+    });
+}
 /**
  * Surface an AMBIGUOUS kind-only evolution hint as an action-required
  * observation. After {@link scopeHintsByPolicy} runs, a hint that still has no
@@ -428,6 +628,67 @@ export function detectUnbindableHintObservations(hints, policy) {
     }
     return observations;
 }
+/**
+ * One health offender as evidence prose: 'health offender: cyclomatic 41 in
+ * foo() (182 lines)'. The metric+value lead so truncation never eats the
+ * signal; function/length are the navigable address parts when known.
+ */
+function describeHealthOffender(offender) {
+    const value = Number.isInteger(offender.value)
+        ? String(offender.value)
+        : offender.value.toFixed(1);
+    let text = `health offender: ${offender.metric} ${value}`;
+    if (offender.function)
+        text += ` in ${offender.function}()`;
+    if (offender.functionLength !== undefined)
+        text += ` (${offender.functionLength} lines)`;
+    return text;
+}
+/**
+ * The producing canonical target health offenders route to. Code shape (the
+ * thing the offenders measure) is a property of the generated IMPLEMENTATION;
+ * the adapter has no artifact contents to walk a per-offender credit path
+ * with, so the trace target is the STATIC implementation producer — the tasks
+ * template that shapes how implementation work is cut. Mirrors
+ * {@link PRODUCING_TARGET_BY_LAST_NODE}'s task → tasks-template mapping.
+ */
+const HEALTH_ROUTING_TARGET_ID = 'artifact-template:tasks';
+/**
+ * Surface health offenders whose routing lands on a FROZEN target as ONE
+ * aggregated ACTION-REQUIRED observation — the honest dead-end. Without this,
+ * a freezing policy makes the offender signal vanish silently: the enrichment
+ * in {@link generateEvolutionHints} only rides on drafts that survive scoping.
+ * Mirrors {@link detectUnbindableHintObservations}' shape and wiring (call it
+ * wherever that one is called, on evolving runs). Returns `[]` when `policy`
+ * is absent or the routing target is evolvable — the enrichment path already
+ * carries the signal there — so the common case stays byte-identical.
+ */
+export function detectFrozenHealthRoutingObservations(report, policy) {
+    if (!policy)
+        return [];
+    const offenders = report.fitnessSample?.healthContributors ?? [];
+    if (offenders.length === 0)
+        return [];
+    if (isCanonicalTargetEvolvable(HEALTH_ROUTING_TARGET_ID, policy))
+        return [];
+    return [
+        {
+            code: 'health-routing-frozen',
+            // ACTION, not DEFECT: the routing worked — the destination is frozen by
+            // operator policy, so the fix is an operator decision (unfreeze or fix
+            // the code by hand), not a tool repair. Same triage rationale as
+            // `evolution-target-unresolved`.
+            severity: 'action',
+            summary: limitText(`${offenders.length} health offender(s) trace to frozen target ${HEALTH_ROUTING_TARGET_ID} — ` +
+                `routing dead-end; pass --evolve-target ${HEALTH_ROUTING_TARGET_ID} or address the code manually`, 420),
+            evidence: offenders.slice(0, 6).map((offender) => ({
+                file: toPosix(offender.file),
+                detail: describeHealthOffender(offender),
+            })),
+            tags: ['health', 'routing', 'frozen', 'action-required'],
+        },
+    ];
+}
 function inferTemplateObservation(candidate) {
     const tags = candidate.tags;
     const templateTag = tags.find((tag) => /^template:/i.test(tag));
@@ -540,6 +801,13 @@ function uniqueByFile(items) {
  * learn → propose bridge: it writes an ARTIFACT under `learn-handoffs/` (never a
  * canonical file), so it is proposal-only. Reuses the existing
  * `learn-handoffs/<change>/<timestamp>/` convention. Returns the file path.
+ *
+ * When any hint carries credit paths, a sibling `slice.md` is written next to
+ * `hints.json` (and referenced via the optional top-level `slice` key) so the
+ * HOST author on the `--from-edits` path can read the real artifact text along
+ * the failing paths — the same CREDIT-PATH SLICE the `--agent` prompt renders.
+ * Old readers ignore unknown top-level keys (`extractHintCandidates` reads only
+ * the hint arrays), so the addition is back-compatible.
  */
 export async function persistLearnHints(opts) {
     const stamp = (opts.now ? opts.now() : new Date())
@@ -548,7 +816,14 @@ export async function persistLearnHints(opts) {
     const dir = path.join(opts.projectRoot, '.synergyspec-selfevolving', 'learn-handoffs', opts.changeName, stamp);
     await fs.mkdir(dir, { recursive: true });
     const file = path.join(dir, 'hints.json');
-    await fs.writeFile(file, JSON.stringify({ evolutionHints: opts.hints }, null, 2) + '\n', 'utf8');
+    const slice = buildProposerSlice(opts.hints);
+    if (slice.length > 0) {
+        await fs.writeFile(path.join(dir, 'slice.md'), `# Credit-path slice: ${opts.changeName}\n\n${slice}\n`, 'utf8');
+    }
+    await fs.writeFile(file, JSON.stringify({
+        evolutionHints: opts.hints,
+        ...(slice.length > 0 ? { slice: 'slice.md' } : {}),
+    }, null, 2) + '\n', 'utf8');
     return file;
 }
 function evalSuitesFor(kind) {

package/dist/core/self-evolution/line-diff.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Line-level diff for the 演进智能体 EVOLVING AGENT (optimizer.step) — loop v2
+ * (self-evolution as in-context RL).
+ *
+ * The EVOLVING AGENT makes ONE bounded edit ≤ L changed lines (added + removed).
+ * To enforce that budget and to feed the 范围⊆诊断 scope⊆diagnosis gate
+ * ({@link import('./scope-gate.js')}), we need an honest line-level account of
+ * which lines the proposed full-file replacement actually changed — not the
+ * whole-file-replacement unified diff `edits-contract.ts` renders (that counts
+ * every line as removed-then-added).
+ *
+ * This is a classic LCS (longest common subsequence) line diff: the lines NOT
+ * on the LCS are the real changes. `linesAdded` / `linesRemoved` are the true
+ * insert/delete counts, and `changedRanges` are the 1-based line spans of the
+ * inserted lines IN THE PROPOSED FILE (a pure deletion that inserts nothing
+ * produces no range — there is no proposed line to anchor it to; its removal
+ * still counts toward `linesRemoved` and the budget).
+ *
+ * Pure + dependency-free so it is golden-testable and reusable by the gate.
+ */
+/** A 1-based, inclusive span of changed (inserted) lines in the PROPOSED file. */
+export interface ChangedRange {
+    /** 1-based first changed line in the proposed file. */
+    startLine: number;
+    /** 1-based last changed line in the proposed file (inclusive). */
+    endLine: number;
+}
+/** Result of {@link lineDiff} for one (current → proposed) file pair. */
+export interface LineDiffResult {
+    /** Count of lines present in the proposed file but not the current file. */
+    linesAdded: number;
+    /** Count of lines present in the current file but not the proposed file. */
+    linesRemoved: number;
+    /** Coalesced 1-based spans of the inserted lines in the proposed file. */
+    changedRanges: ChangedRange[];
+}
+/**
+ * Compute the LCS-based line diff between `currentContent` and
+ * `proposedContent`. Lines are matched with the standard dynamic-programming
+ * LCS so that an unchanged block in the middle of an edit is not double-counted
+ * as remove+add. `changedRanges` covers the inserted lines of the proposed file
+ * (1-based), coalescing adjacent inserts into one span.
+ */
+export declare function lineDiff(currentContent: string, proposedContent: string): LineDiffResult;
+/** One edit: the COMPLETE new contents for a file the agent proposes to rewrite. */
+export interface DiffEdit {
+    relPath: string;
+    content: string;
+}
+/**
+ * Sum added + removed lines across every edit, comparing each edit's proposed
+ * content to the current on-disk content of the same file. An edit whose
+ * `relPath` has no current entry is diffed against empty content (every
+ * proposed line is an insert) — defensive; the EVOLVING AGENT only edits
+ * existing lineage files, so this should not happen in practice.
+ *
+ * This is the value the EVOLVING AGENT's ≤ L budget is checked against.
+ */
+export declare function countChangedLines(edits: readonly DiffEdit[], currentFiles: readonly DiffEdit[]): number;
+//# sourceMappingURL=line-diff.d.ts.map

package/dist/core/self-evolution/line-diff.js

@@ -0,0 +1,130 @@
+/**
+ * Line-level diff for the 演进智能体 EVOLVING AGENT (optimizer.step) — loop v2
+ * (self-evolution as in-context RL).
+ *
+ * The EVOLVING AGENT makes ONE bounded edit ≤ L changed lines (added + removed).
+ * To enforce that budget and to feed the 范围⊆诊断 scope⊆diagnosis gate
+ * ({@link import('./scope-gate.js')}), we need an honest line-level account of
+ * which lines the proposed full-file replacement actually changed — not the
+ * whole-file-replacement unified diff `edits-contract.ts` renders (that counts
+ * every line as removed-then-added).
+ *
+ * This is a classic LCS (longest common subsequence) line diff: the lines NOT
+ * on the LCS are the real changes. `linesAdded` / `linesRemoved` are the true
+ * insert/delete counts, and `changedRanges` are the 1-based line spans of the
+ * inserted lines IN THE PROPOSED FILE (a pure deletion that inserts nothing
+ * produces no range — there is no proposed line to anchor it to; its removal
+ * still counts toward `linesRemoved` and the budget).
+ *
+ * Pure + dependency-free so it is golden-testable and reusable by the gate.
+ */
+/**
+ * Split content into lines for diffing. A trailing newline is normalized away
+ * first (so `"a\n"` and `"a"` are one line, matching `renderUnifiedDiff`'s
+ * convention); empty content is zero lines, never `['']`.
+ */
+function toLines(content) {
+    if (content.length === 0)
+        return [];
+    return content.replace(/\n$/, '').split('\n');
+}
+/**
+ * Compute the LCS-based line diff between `currentContent` and
+ * `proposedContent`. Lines are matched with the standard dynamic-programming
+ * LCS so that an unchanged block in the middle of an edit is not double-counted
+ * as remove+add. `changedRanges` covers the inserted lines of the proposed file
+ * (1-based), coalescing adjacent inserts into one span.
+ */
+export function lineDiff(currentContent, proposedContent) {
+    const a = toLines(currentContent); // current
+    const b = toLines(proposedContent); // proposed
+    const n = a.length;
+    const m = b.length;
+    // LCS length table: lcs[i][j] = LCS length of a[i..] and b[j..].
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    // 1-based line numbers (in b) of every inserted proposed line.
+    const insertedProposedLines = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            // Common line: advance both, no change.
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            // Dropping a[i] keeps a longer LCS → a[i] was removed.
+            linesRemoved++;
+            i++;
+        }
+        else {
+            // Dropping b[j] keeps a longer LCS → b[j] was inserted.
+            linesAdded++;
+            insertedProposedLines.push(j + 1);
+            j++;
+        }
+    }
+    // Tail: leftover current lines are removals, leftover proposed lines inserts.
+    while (i < n) {
+        linesRemoved++;
+        i++;
+    }
+    while (j < m) {
+        linesAdded++;
+        insertedProposedLines.push(j + 1);
+        j++;
+    }
+    return {
+        linesAdded,
+        linesRemoved,
+        changedRanges: coalesce(insertedProposedLines),
+    };
+}
+/** Coalesce a sorted list of 1-based line numbers into inclusive ranges. */
+function coalesce(lines) {
+    if (lines.length === 0)
+        return [];
+    const ranges = [];
+    let start = lines[0];
+    let prev = lines[0];
+    for (let k = 1; k < lines.length; k++) {
+        const cur = lines[k];
+        if (cur === prev + 1) {
+            prev = cur;
+            continue;
+        }
+        ranges.push({ startLine: start, endLine: prev });
+        start = cur;
+        prev = cur;
+    }
+    ranges.push({ startLine: start, endLine: prev });
+    return ranges;
+}
+/**
+ * Sum added + removed lines across every edit, comparing each edit's proposed
+ * content to the current on-disk content of the same file. An edit whose
+ * `relPath` has no current entry is diffed against empty content (every
+ * proposed line is an insert) — defensive; the EVOLVING AGENT only edits
+ * existing lineage files, so this should not happen in practice.
+ *
+ * This is the value the EVOLVING AGENT's ≤ L budget is checked against.
+ */
+export function countChangedLines(edits, currentFiles) {
+    const currentByPath = new Map(currentFiles.map((f) => [f.relPath.replace(/\\/g, '/'), f.content]));
+    let total = 0;
+    for (const edit of edits) {
+        const rel = edit.relPath.replace(/\\/g, '/');
+        const current = currentByPath.get(rel) ?? '';
+        const d = lineDiff(current, edit.content);
+        total += d.linesAdded + d.linesRemoved;
+    }
+    return total;
+}
+//# sourceMappingURL=line-diff.js.map

package/dist/core/self-evolution/policy/fs-safe.d.ts

@@ -0,0 +1,19 @@
+/** Throw if `abs` resolves outside `repoRoot`. */
+export declare function assertWithinRepo(repoRoot: string, abs: string): void;
+/**
+ * Atomic write via sibling tmp file + rename; cleans up on rename failure. After
+ * the rename, fsync the file and (best-effort) its parent directory so a host
+ * crash cannot lose a just-renamed record a later separate process relies on —
+ * the rename is only durable once the directory entry itself is flushed.
+ */
+export declare function writeFileAtomic(abs: string, content: string): Promise<void>;
+/**
+ * Append `content` to a file and fsync the file descriptor so a host crash
+ * cannot lose the just-appended record. Used by the append-only stores (the
+ * 版本账本 ledger and the 否决缓冲 reject-buffer): a later SEPARATE process
+ * (`resumeEpisode`) relies on these records being durable, so the OS write cache
+ * must be flushed before we return. Does NOT change the bytes written (one
+ * `append` of `content`); only adds the fsync. Byte content is the caller's.
+ */
+export declare function appendFileDurable(abs: string, content: string): Promise<void>;
+//# sourceMappingURL=fs-safe.d.ts.map