synergyspec-selfevolving 2.1.6 → 2.1.8

package/dist/commands/self-evolution.js

@@ -423,13 +423,14 @@ function packageHostEdits(editsInput, allowedFiles, currentFiles, group, targetI
     }
     const validated = validateCandidateEdits(editsInput.edits, allowedFiles);
     const oldByPath = new Map(currentFiles.map((f) => [f.relPath.replace(/\\/g, '/'), f.content]));
-    // No-op guard: if every edit's content equals the current file there is
-    // nothing to evolve — surface it as a no-op (placeholder), like the agent path.
-    const changesSomething = validated.some((e) => (oldByPath.get(e.relPath) ?? '') !== e.content);
-    if (!changesSomething) {
+    // No-op guard: package only edits whose content differs from the current
+    // file. If none remain there is nothing to evolve — surface it as a no-op
+    // (placeholder), like the agent path.
+    const changed = validated.filter((e) => (oldByPath.get(e.relPath) ?? '') !== e.content);
+    if (changed.length === 0) {
         throw new EvolvingAgentNoOp();
     }
-    const diffPatch = validated
+    const diffPatch = changed
         .map((e) => renderUnifiedDiff(e.relPath, oldByPath.get(e.relPath) ?? '', e.content))
         .join('\n');
     const rationale = (editsInput.rationale ?? '').trim() ||
@@ -437,9 +438,9 @@ function packageHostEdits(editsInput, allowedFiles, currentFiles, group, targetI
     return {
         targetId,
         diffPatch,
-        changedFiles: validated.map((e) => e.relPath),
+        changedFiles: changed.map((e) => e.relPath),
         rationale,
-        edits: validated,
+        edits: changed,
     };
 }
 /**

package/dist/core/self-evolution/edits-contract.d.ts

@@ -53,6 +53,9 @@ export interface CanonicalProposeOutput {
  * {@link EvolvingAgentOutputInvalid} for any shape / frozen / scope
  * violation. Path traversal and absolute paths are rejected transitively: they
  * can never be a member of `allowedFiles`, so they fail the scope check.
+ * Duplicate relPaths are rejected because full-file replacements have no
+ * stable sequencing semantics; allowing them would let a later entry silently
+ * override an earlier one.
  */
 export declare function validateCandidateEdits(rawEdits: readonly unknown[], allowedFiles: readonly string[]): {
     relPath: string;

package/dist/core/self-evolution/edits-contract.js

@@ -58,6 +58,9 @@ export const CanonicalProposerInvocationError = EvolvingAgentInvocationError;
  * {@link EvolvingAgentOutputInvalid} for any shape / frozen / scope
  * violation. Path traversal and absolute paths are rejected transitively: they
  * can never be a member of `allowedFiles`, so they fail the scope check.
+ * Duplicate relPaths are rejected because full-file replacements have no
+ * stable sequencing semantics; allowing them would let a later entry silently
+ * override an earlier one.
  */
 export function validateCandidateEdits(rawEdits, allowedFiles) {
     if (rawEdits.length === 0) {
@@ -66,6 +69,7 @@ export function validateCandidateEdits(rawEdits, allowedFiles) {
     const allowed = new Set(allowedFiles.map((p) => p.replace(/\\/g, '/')));
     const frozen = new Set(GATE_DEFINING_FILES.map((p) => p.replace(/\\/g, '/')));
     const validated = [];
+    const seen = new Set();
     for (const e of rawEdits) {
         if (!e || typeof e !== 'object') {
             throw new EvolvingAgentOutputInvalid('edit entry must be an object');
@@ -82,6 +86,10 @@ export function validateCandidateEdits(rawEdits, allowedFiles) {
         if (!allowed.has(norm)) {
             throw new EvolvingAgentOutputInvalid(`edit relPath "${relPath}" is outside the target's declared files`);
         }
+        if (seen.has(norm)) {
+            throw new EvolvingAgentOutputInvalid(`edit relPath "${relPath}" appears more than once; combine changes into one full-file content edit`);
+        }
+        seen.add(norm);
         validated.push({ relPath: norm, content });
     }
     return validated;

package/dist/core/self-evolution/evolving-agent.d.ts

@@ -41,6 +41,7 @@ import { type EvidenceCheck } from './promote.js';
 import { type TargetProtection } from './success-channel.js';
 import { type RejectBufferEntry } from './policy/reject-buffer.js';
 import { type PolicyPrediction, type PolicyLedgerEntry } from './policy/policy-store.js';
+import { type DiffEdit } from './line-diff.js';
 import { type DiagnosisGap } from './scope-gate.js';
 import type { WeaknessClass, GapSeverity } from './reward-agent.js';
 /** Default edit budget L: at most this many changed lines (added + removed). */
@@ -122,17 +123,40 @@ export interface EvolvingAgentRefusal {
     kind: 'refusal';
     reason: string;
 }
+/** Legacy full-file replacement, still accepted for compatibility and small files. */
+export interface EvolvingAgentFullContentEdit {
+    relPath: string;
+    content: string;
+}
+/** Replace one exact existing text block with a new text block. */
+export interface EvolvingAgentReplaceTextEdit {
+    relPath: string;
+    operation: 'replaceText';
+    find: string;
+    replace: string;
+}
+/** Insert text adjacent to one exact marker block. */
+export interface EvolvingAgentInsertMarkerEdit {
+    relPath: string;
+    operation: 'insertAfter' | 'insertBefore';
+    marker: string;
+    insert: string;
+}
+export type EvolvingAgentEditInstruction = EvolvingAgentFullContentEdit | EvolvingAgentReplaceTextEdit | EvolvingAgentInsertMarkerEdit;
 /** A concrete bounded edit with its checkable prediction. */
 export interface EvolvingAgentEdit {
     kind: 'edit';
     rationale: string;
     prediction: PolicyPrediction;
-    edits: {
-        relPath: string;
-        content: string;
-    }[];
+    edits: EvolvingAgentEditInstruction[];
 }
 export type ParsedEvolvingAgentResponse = EvolvingAgentRefusal | EvolvingAgentEdit;
+export interface ResolvedEvolvingAgentEdit {
+    kind: 'edit';
+    rationale: string;
+    prediction: PolicyPrediction;
+    edits: DiffEdit[];
+}
 /**
  * Parse the model's single `json:patch` block. Accepts EITHER the refusal shape
  * (`{edits: [], refusal: string}`) OR a concrete edit (`{rationale, prediction,
@@ -144,6 +168,11 @@ export type ParsedEvolvingAgentResponse = EvolvingAgentRefusal | EvolvingAgentEd
  * them); this only enforces the SHAPE of the contract.
  */
 export declare function parseEvolvingAgentResponse(text: string): ParsedEvolvingAgentResponse;
+/**
+ * Expand model-facing compact edit operations into the full-file DiffEdit shape
+ * consumed by the existing static, budget, scope, and policy-promotion gates.
+ */
+export declare function resolveEvolvingAgentEditInstructions(candidate: EvolvingAgentEdit, currentFiles: readonly DiffEdit[]): ResolvedEvolvingAgentEdit;
 export interface RunEvolvingAgentOptions {
     repoRoot: string;
     episodeId: string;

package/dist/core/self-evolution/evolving-agent.js

@@ -101,12 +101,21 @@ function preludeLines(editBudget) {
         ' "prediction": {"metric": "loss" | "passRate" | "healthPenalty",',
         '                "direction": "down" | "up",',
         '                "checkBy": "<one sentence: how a later episode settles this>"},',
-        ' "edits": [{"relPath": "<one of the allowed files>", "content": "<FULL new file contents>"}]}',
+        ' "edits": [{"relPath": "<one of the allowed files>",',
+        '             "operation": "replaceText",',
+        '             "find": "<exact existing text that occurs once>",',
+        '             "replace": "<replacement text>"}]}',
         '```',
         '',
         'Rules:',
         '- Only edit files listed under "CANONICAL TARGET" below. Never invent paths.',
-        "- Each edit's `content` is the COMPLETE new file, not a patch fragment.",
+        '- Prefer compact edit operations: `replaceText`, `insertAfter`, or `insertBefore`.',
+        '- `replaceText.find` and marker text must match exactly one location in the current file.',
+        '- For `insertAfter`/`insertBefore`, include a non-empty `marker` field and a string `insert` field.',
+        '- Empty `edits` is valid only with a non-empty `refusal`; never emit `{"edits":[]}` alone.',
+        '- Include needed newlines inside `replace`/`insert`; the runner will expand the operation locally.',
+        '- Legacy `content` full-file replacements are accepted only for small files or true rewrites.',
+        '- Do not re-emit a large canonical file just to make a small localized edit.',
         '- You NEVER score and you NEVER touch the gate/oracle files.',
     ].join('\n');
 }
@@ -246,20 +255,153 @@ export function parseEvolvingAgentResponse(text) {
         // Empty edits with no refusal reason is a malformed no-op, not a refusal.
         throw new EvolvingAgentNoOp();
     }
-    // Concrete-edit shape: validate prediction + edit shapes.
+    if (Object.prototype.hasOwnProperty.call(o, 'refusal')) {
+        throw new EvolvingAgentOutputInvalid('refusal is only valid with empty edits; choose either a refusal or a concrete edit');
+    }
+    // Concrete-edit shape: validate prediction + edit instruction shapes.
     const prediction = parsePrediction(o.prediction);
     const edits = [];
     for (const e of rawEdits) {
-        const relPath = e?.relPath;
-        const content = e?.content;
-        if (typeof relPath !== 'string' || typeof content !== 'string') {
-            throw new EvolvingAgentOutputInvalid('edit must have string relPath and string content');
+        if (!e || typeof e !== 'object') {
+            throw new EvolvingAgentOutputInvalid('edit entry must be an object');
+        }
+        const entry = e;
+        const relPath = entry.relPath;
+        if (typeof relPath !== 'string') {
+            throw new EvolvingAgentOutputInvalid('edit must have string relPath');
+        }
+        const normalizedRelPath = relPath.replace(/\\/g, '/');
+        const hasContent = Object.prototype.hasOwnProperty.call(entry, 'content');
+        const operation = entry.operation;
+        if (hasContent && operation !== undefined) {
+            throw new EvolvingAgentOutputInvalid('edit must use either legacy `content` or a compact `operation`, not both');
+        }
+        if (hasContent) {
+            if (typeof entry.content !== 'string') {
+                throw new EvolvingAgentOutputInvalid('legacy edit content must be a string');
+            }
+            edits.push({ relPath: normalizedRelPath, content: entry.content });
+            continue;
+        }
+        if (operation === 'replaceText') {
+            if (typeof entry.find !== 'string' || entry.find.length === 0) {
+                throw new EvolvingAgentOutputInvalid('replaceText edit requires a non-empty string `find`');
+            }
+            if (typeof entry.replace !== 'string') {
+                throw new EvolvingAgentOutputInvalid('replaceText edit requires string `replace`');
+            }
+            edits.push({
+                relPath: normalizedRelPath,
+                operation,
+                find: entry.find,
+                replace: entry.replace,
+            });
+            continue;
         }
-        edits.push({ relPath: relPath.replace(/\\/g, '/'), content });
+        if (operation === 'insertAfter' || operation === 'insertBefore') {
+            if (typeof entry.marker !== 'string' || entry.marker.length === 0) {
+                throw new EvolvingAgentOutputInvalid(`${operation} edit requires a non-empty string marker`);
+            }
+            if (typeof entry.insert !== 'string') {
+                throw new EvolvingAgentOutputInvalid(`${operation} edit requires string insert`);
+            }
+            edits.push({
+                relPath: normalizedRelPath,
+                operation,
+                marker: entry.marker,
+                insert: entry.insert,
+            });
+            continue;
+        }
+        throw new EvolvingAgentOutputInvalid("edit must have legacy string `content` or operation 'replaceText' | 'insertAfter' | 'insertBefore'");
     }
     const rationale = typeof o.rationale === 'string' ? o.rationale.trim() : '';
     return { kind: 'edit', rationale, prediction, edits };
 }
+function findExactlyOnce(content, needle, description) {
+    let foundAt = -1;
+    let count = 0;
+    let searchFrom = 0;
+    while (true) {
+        const idx = content.indexOf(needle, searchFrom);
+        if (idx === -1)
+            break;
+        foundAt = idx;
+        count += 1;
+        if (count > 1)
+            break;
+        searchFrom = idx + 1;
+    }
+    if (count !== 1) {
+        throw new EvolvingAgentOutputInvalid(`${description} must match exactly one location in the current file, found ${count} (missing or ambiguous)`);
+    }
+    return foundAt;
+}
+/**
+ * Expand model-facing compact edit operations into the full-file DiffEdit shape
+ * consumed by the existing static, budget, scope, and policy-promotion gates.
+ */
+export function resolveEvolvingAgentEditInstructions(candidate, currentFiles) {
+    const currentByPath = new Map(currentFiles.map((f) => [f.relPath.replace(/\\/g, '/'), f.content]));
+    const proposedByPath = new Map();
+    const editModeByPath = new Map();
+    const order = [];
+    const rememberPath = (relPath) => {
+        if (!proposedByPath.has(relPath))
+            order.push(relPath);
+    };
+    for (const raw of candidate.edits) {
+        const relPath = raw.relPath.replace(/\\/g, '/');
+        const mode = 'content' in raw ? 'fullContent' : 'compact';
+        const previousMode = editModeByPath.get(relPath);
+        if (mode === 'fullContent' && previousMode !== undefined) {
+            throw new EvolvingAgentOutputInvalid(`legacy full-file content edit for "${relPath}" cannot be combined with other edits for the same file`);
+        }
+        if (mode === 'compact' && previousMode === 'fullContent') {
+            throw new EvolvingAgentOutputInvalid(`legacy full-file content edit for "${relPath}" cannot be combined with other edits for the same file`);
+        }
+        editModeByPath.set(relPath, mode);
+        if ('content' in raw) {
+            rememberPath(relPath);
+            proposedByPath.set(relPath, raw.content);
+            continue;
+        }
+        const current = proposedByPath.get(relPath) ?? currentByPath.get(relPath);
+        if (current === undefined) {
+            throw new EvolvingAgentOutputInvalid(`compact edit for "${relPath}" cannot be expanded because the current file was not loaded`);
+        }
+        rememberPath(relPath);
+        if (raw.operation === 'replaceText') {
+            const start = findExactlyOnce(current, raw.find, `replaceText.find for "${relPath}"`);
+            const content = current.slice(0, start) +
+                raw.replace +
+                current.slice(start + raw.find.length);
+            proposedByPath.set(relPath, content);
+            continue;
+        }
+        const markerStart = findExactlyOnce(current, raw.marker, `${raw.operation}.marker for "${relPath}"`);
+        const insertAt = raw.operation === 'insertAfter'
+            ? markerStart + raw.marker.length
+            : markerStart;
+        proposedByPath.set(relPath, current.slice(0, insertAt) + raw.insert + current.slice(insertAt));
+    }
+    return {
+        kind: 'edit',
+        rationale: candidate.rationale,
+        prediction: candidate.prediction,
+        edits: order.map((relPath) => ({ relPath, content: proposedByPath.get(relPath) ?? '' })),
+    };
+}
+function dropByteIdenticalEdits(candidate, currentFiles) {
+    const currentByPath = new Map(currentFiles.map((f) => [f.relPath.replace(/\\/g, '/'), f.content]));
+    return {
+        ...candidate,
+        edits: candidate.edits.filter((edit) => {
+            const current = currentByPath.get(edit.relPath.replace(/\\/g, '/'));
+            return current === undefined || current !== edit.content;
+        }),
+    };
+}
 function parsePrediction(raw) {
     if (!raw || typeof raw !== 'object') {
         throw new EvolvingAgentOutputInvalid('a concrete edit requires a `prediction` object {metric, direction, checkBy}');
@@ -475,6 +617,7 @@ export async function runEvolvingAgent(opts) {
             : `${basePrompt}\n\n# PREVIOUS ATTEMPT WAS REJECTED\n${feedback}\n` +
                 'Re-emit EXACTLY ONE ```json:patch fenced block — either a refusal ' +
                 '({"edits": [], "refusal": string}) or a single bounded edit ' +
+                'using a compact operation or legacy full-file content ' +
                 '({"rationale", "prediction", "edits"}), staying inside the diagnosed ' +
                 'sections and within the changed-line budget.';
         const run = await runHeadlessAgent(prompt, {
@@ -490,14 +633,19 @@ export async function runEvolvingAgent(opts) {
             throw new EvolvingAgentInvocationError(run.stderr);
         }
         try {
-            const candidate = parseEvolvingAgentResponse(run.stdout);
-            if (candidate.kind === 'refusal') {
-                parsed = candidate;
+            const response = parseEvolvingAgentResponse(run.stdout);
+            if (response.kind === 'refusal') {
+                parsed = response;
                 break;
             }
+            const resolved = resolveEvolvingAgentEditInstructions(response, currentFiles);
             // Static-shape edit: validate scope-to-target + frozen freeze here so a
             // bad path is a REPAIRABLE failure (the evolving agent's repair contract).
-            validateCandidateEdits(candidate.edits, allowedFiles);
+            validateCandidateEdits(resolved.edits, allowedFiles);
+            const candidate = dropByteIdenticalEdits(resolved, currentFiles);
+            if (candidate.edits.length === 0) {
+                throw new EvolvingAgentOutputInvalid('edit makes no changes against the current policy head - emit a refusal or a real bounded edit');
+            }
             // ≤ L budget (repairable).
             const changed = countChangedLines(candidate.edits, currentFiles);
             if (changed > editBudget) {
@@ -537,7 +685,8 @@ export async function runEvolvingAgent(opts) {
             break;
         }
         catch (err) {
-            if (err instanceof EvolvingAgentOutputInvalid && attempt < maxRepairAttempts) {
+            if ((err instanceof EvolvingAgentOutputInvalid || err instanceof EvolvingAgentNoOp) &&
+                attempt < maxRepairAttempts) {
                 feedback = gateFeedback(err.message);
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synergyspec-selfevolving",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "synergyspec-selfevolving",