synergyspec-selfevolving 1.4.0 → 2.1.0

package/dist/core/archive.d.ts

@@ -12,6 +12,5 @@ export declare class ArchiveCommand {
     private selectChange;
     private getArchiveDate;
     private checkArchiveReadiness;
-    private recordSelfEvolutionObservations;
 }
 //# sourceMappingURL=archive.d.ts.map

package/dist/core/archive.js

@@ -5,8 +5,6 @@ import { getChangeReadiness, } from './change-readiness.js';
 import { Validator } from './validation/validator.js';
 import chalk from 'chalk';
 import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from './specs-apply.js';
-import { evaluateTaskDecompositionForChange, isEvolutionPartEnabled, parseEvolutionSwitchOptions, recordTemplateVariantObservation, verifySpecCodeAlignmentForChange, } from './self-evolution/index.js';
-import { isReadOnlyMode } from '../runtime/side-effects.js';
 /**
  * Recursively copy a directory. Used when fs.rename fails (e.g. EPERM on Windows).
  */
@@ -248,7 +246,6 @@ export class ArchiveCommand {
         }
         // Create archive directory if needed
         await fs.mkdir(archiveDir, { recursive: true });
-        await this.recordSelfEvolutionObservations(targetPath, changeName, parseEvolutionSwitchOptions(options));
         // Move change to archive (uses copy+remove on EPERM/EXDEV, e.g. Windows)
         await moveDirectory(changeDir, archivePath);
         console.log(`Change '${changeName}' archived as '${archiveName}'.`);
@@ -338,60 +335,5 @@ export class ArchiveCommand {
         console.log(chalk.yellow('Archive cancelled. Complete the change or rerun with --force-incomplete.'));
         return false;
     }
-    async recordSelfEvolutionObservations(projectRoot, changeName, evolutionSwitches) {
-        if (isReadOnlyMode()) {
-            return;
-        }
-        if (!isEvolutionPartEnabled(evolutionSwitches, 'template-variants')) {
-            return;
-        }
-        try {
-            const taskQuality = isEvolutionPartEnabled(evolutionSwitches, 'task-decomposition')
-                ? evaluateTaskDecompositionForChange({ projectRoot, changeName })
-                : null;
-            const alignment = isEvolutionPartEnabled(evolutionSwitches, 'alignment-verifier')
-                ? verifySpecCodeAlignmentForChange({ projectRoot, changeName })
-                : null;
-            const artifacts = ['proposal', 'usecases', 'specs', 'design', 'tasks'];
-            let recorded = 0;
-            for (const artifactId of artifacts) {
-                if (recordTemplateVariantObservation({
-                    projectRoot,
-                    schemaName: 'spec-driven',
-                    artifactId,
-                    changeName,
-                    observation: {
-                        taskCompletionRatio: taskQuality?.metrics.completionRatio,
-                        taskQualityScore: taskQuality?.score,
-                        alignmentScore: alignment?.score,
-                        reworkCount: countReworkSignals((taskQuality?.findings.length ?? 0) + (alignment?.findings.length ?? 0)),
-                        notes: [
-                            'archive observation',
-                            taskQuality ? `task=${taskQuality.score.toFixed(2)}` : 'task=disabled',
-                            alignment ? `alignment=${alignment.score.toFixed(2)}` : 'alignment=disabled',
-                        ].join(': '),
-                    },
-                })) {
-                    recorded++;
-                }
-            }
-            if (recorded > 0) {
-                console.log(`Self-evolution observations recorded for ${recorded} template variant(s).`);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.log(chalk.yellow(`Warning: self-evolution observation skipped: ${message}`));
-        }
-    }
-}
-function countReworkSignals(findingCount) {
-    if (findingCount <= 0)
-        return 0;
-    if (findingCount <= 2)
-        return 1;
-    if (findingCount <= 5)
-        return 2;
-    return 3;
 }
 //# sourceMappingURL=archive.js.map

package/dist/core/artifact-graph/instruction-loader.d.ts

@@ -1,6 +1,6 @@
 import { ArtifactGraph } from './graph.js';
 import type { CompletedSet } from './types.js';
-import { type EvolutionSwitchInput, type EvolutionSwitches, type TemplateVariantSelection } from '../self-evolution/index.js';
+import { type EvolutionSwitchInput, type EvolutionSwitches } from '../self-evolution/index.js';
 /**
  * Error thrown when loading a template fails.
  */
@@ -49,9 +49,7 @@ export interface ArtifactInstructions {
     rules: string[] | undefined;
     /** Template content (structure to follow - this IS the output format) */
     template: string;
-    /** Selected template variant, if project self-evolution chose one */
-    templateVariant?: TemplateVariantSelection;
-    /** Self-evolution context assembled from template selection, archive memory, and quality signals */
+    /** Self-evolution context assembled from archive memory and quality signals */
     selfEvolutionContext?: string;
     /** Per-run evolution switches that controlled this instruction payload */
     evolutionSwitches?: EvolutionSwitches;

package/dist/core/artifact-graph/instruction-loader.js

@@ -7,7 +7,7 @@ import { resolveSchemaForChange } from '../../utils/change-metadata.js';
 import { readProjectConfig, validateConfigRules, validateConfigSelfEvolutionTargets, } from '../project-config.js';
 import { CANONICAL_TARGETS } from '../self-evolution/canonical-targets.js';
 import { ensureDesignConstitution } from '../design-constitution.js';
-import { findSimilarArchiveExperiences, isEvolutionPartEnabled, loadTemplateWithVariant, renderArchiveExperienceBlock, renderTaskStrategyContext, renderTemplateVariantContext, resolveEvolutionSwitches, evaluateTaskDecomposition, } from '../self-evolution/index.js';
+import { findSimilarArchiveExperiences, isEvolutionPartEnabled, renderArchiveExperienceBlock, renderTaskStrategyContext, resolveEvolutionSwitches, evaluateTaskDecomposition, } from '../self-evolution/index.js';
 // Session-level cache for validation warnings (avoid repeating same warnings)
 const shownWarnings = new Set();
 /**
@@ -96,27 +96,7 @@ export function generateInstructions(context, artifactId, projectRoot, options =
         throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'`);
     }
     const evolutionSwitches = resolveEvolutionSwitches(options.evolution);
-    const templateWithVariant = isEvolutionPartEnabled(evolutionSwitches, 'template-variants')
-        ? loadTemplateWithVariant({
-            schemaName: context.schemaName,
-            artifactId: artifact.id,
-            templatePath: artifact.template,
-            projectRoot: context.projectRoot,
-            loadBuiltIn: loadTemplate,
-        })
-        : {
-            content: loadTemplate(context.schemaName, artifact.template, context.projectRoot),
-            selection: {
-                id: 'built-in',
-                schema: context.schemaName,
-                artifact: artifact.id,
-                templatePath: artifact.template,
-                score: 0.5,
-                observationCount: 0,
-                source: 'built-in',
-                reason: 'template evolution disabled for this run',
-            },
-        };
+    const templateContent = loadTemplate(context.schemaName, artifact.template, context.projectRoot);
     const dependencies = getDependencyInfo(artifact, context.graph, context.completed);
     const unlocks = getUnlockedArtifacts(context.graph, artifactId);
     // Use projectRoot from context if not explicitly provided
@@ -167,7 +147,6 @@ export function generateInstructions(context, artifactId, projectRoot, options =
     const selfEvolutionContext = buildSelfEvolutionContext({
         context,
         artifactId,
-        templateVariant: templateWithVariant.selection,
         configContext,
         evolutionSwitches,
     });
@@ -181,8 +160,7 @@ export function generateInstructions(context, artifactId, projectRoot, options =
         instruction: artifact.instruction,
         context: configContext,
         rules: configRules,
-        template: templateWithVariant.content,
-        templateVariant: templateWithVariant.selection,
+        template: templateContent,
         selfEvolutionContext,
         evolutionSwitches,
         dependencies,
@@ -191,12 +169,6 @@ export function generateInstructions(context, artifactId, projectRoot, options =
 }
 function buildSelfEvolutionContext(args) {
     const blocks = [];
-    if (isEvolutionPartEnabled(args.evolutionSwitches, 'template-variants') && args.templateVariant) {
-        const variantContext = renderTemplateVariantContext(args.templateVariant);
-        if (variantContext) {
-            blocks.push(variantContext);
-        }
-    }
     if (isEvolutionPartEnabled(args.evolutionSwitches, 'archive-memory')) {
         const query = [
             args.context.changeName,

package/dist/core/fitness/loss.d.ts

@@ -6,10 +6,10 @@
  *   healthPenalty  = normalized SlopCodeBench code-health penalty
  *                    (structural_erosion ⊕ verbosity)
  *
- * Functional correctness is ALSO used as a hard GATE at GA selection/promotion
- * (a variant whose code fails its tests cannot win); this module only computes
- * the continuous loss scalar used to rank passers. See
- * todo/learn-self-evolution-migration-plan.md.
+ * This loss is the objective evidence the 奖励智能体 (REWARD AGENT) anchors
+ * on for an episode: functional correctness is ALSO a hard GATE
+ * (a change whose code fails its tests cannot be promoted), while this module
+ * only computes the continuous loss scalar used to compare passers.
  */
 export interface PerChangeLoss {
     /** 1 − pass_rate, in [0,1]. */
@@ -45,7 +45,7 @@ export interface ComputeLossInput {
      * the loss is byte-identical to the functional⊕health baseline regardless of
      * `verified` — the trajectory signal is recorded on the FitnessSample for
      * auditing without yet moving selection. Raise it to let unverified
-     * candidates be down-weighted (never hard-disqualified) in GA selection.
+     * candidates be down-weighted (never hard-disqualified) when comparing them.
      */
     unverifiedWeight?: number;
 }

package/dist/core/fitness/loss.js

@@ -6,10 +6,10 @@
  *   healthPenalty  = normalized SlopCodeBench code-health penalty
  *                    (structural_erosion ⊕ verbosity)
  *
- * Functional correctness is ALSO used as a hard GATE at GA selection/promotion
- * (a variant whose code fails its tests cannot win); this module only computes
- * the continuous loss scalar used to rank passers. See
- * todo/learn-self-evolution-migration-plan.md.
+ * This loss is the objective evidence the 奖励智能体 (REWARD AGENT) anchors
+ * on for an episode: functional correctness is ALSO a hard GATE
+ * (a change whose code fails its tests cannot be promoted), while this module
+ * only computes the continuous loss scalar used to compare passers.
  */
 function clamp01(v) {
     if (Number.isNaN(v))

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

@@ -57,6 +57,14 @@ function findAssertion(lines, from) {
 function cleanToken(value) {
     return value.replace(/^[`'"]+|[`'"]+$/g, '');
 }
+/**
+ * POSIX-normalize a path so a Windows pytest path (`tests\test_x.py`) matches the
+ * already-POSIX-normalized file-edit paths in the action skeleton — the reward
+ * agent's renamed/edited-test caveat compares the two by exact string.
+ */
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
 /**
  * Extract failing test ids + assertion lines from observed runner output.
  * Returns `[]` when nothing is recognized. Deduplicates by testId, preserves
@@ -86,7 +94,7 @@ export function parseTestFailures(output) {
             const inline = pytest[2]?.trim();
             push({
                 testId,
-                file: testId.split('::')[0],
+                file: toPosix(testId.split('::')[0]),
                 ...(inline
                     ? { assertion: capAssertion(inline) }
                     : (() => {
@@ -98,7 +106,7 @@ export function parseTestFailures(output) {
         }
         const vitest = VITEST_FAIL_RE.exec(line);
         if (vitest) {
-            const file = cleanToken(vitest[1]);
+            const file = toPosix(cleanToken(vitest[1]));
             const rest = vitest[2]?.trim();
             const testId = rest ? `${file} > ${rest}` : file;
             const assertion = findAssertion(lines, i);

package/dist/core/project-config.d.ts

@@ -25,6 +25,25 @@ export declare const ProjectConfigSchema: z.ZodObject<{
             evolve: z.ZodBoolean;
         }, z.core.$strip>>>;
         focus: z.ZodOptional<z.ZodBoolean>;
+        advantageRollbackThreshold: z.ZodOptional<z.ZodNumber>;
+        editBudget: z.ZodOptional<z.ZodNumber>;
+        reward: z.ZodOptional<z.ZodObject<{
+            samples: z.ZodOptional<z.ZodNumber>;
+            noiseFloor: z.ZodOptional<z.ZodNumber>;
+            orderSwap: z.ZodOptional<z.ZodBoolean>;
+            requireCorrectnessGate: z.ZodOptional<z.ZodBoolean>;
+            tamperCheck: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                flag: "flag";
+                block: "block";
+            }>>;
+        }, z.core.$strip>>;
+        critic: z.ZodOptional<z.ZodObject<{
+            baselineMode: z.ZodOptional<z.ZodEnum<{
+                "re-test": "re-test";
+                "re-do": "re-do";
+            }>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     health: z.ZodOptional<z.ZodObject<{
         source: z.ZodDefault<z.ZodEnum<{

package/dist/core/project-config.js

@@ -49,6 +49,53 @@ export const ProjectConfigSchema = z.object({
         // hint instead of silently dropping them. Set `focus: false` (or pass
         // `learn --no-focus`) to drop frozen-kind signals silently, as before.
         focus: z.boolean().optional(),
+        // Loop v2 (self-evolution as in-context RL): the advantage ＝ reward(主臂) −
+        // reward(基线臂) threshold below which the episode-orchestrator rolls the
+        // 策略 POLICY back to the prior version before the 演进智能体 EVOLVING AGENT
+        // runs. Default 0 — a non-positive advantage (the new policy did not beat
+        // the baseline) triggers a rollback. Optional/omitted ⇒ the orchestrator's
+        // built-in default applies.
+        advantageRollbackThreshold: z.number().optional(),
+        // Loop v2: the edit budget L (max changed lines, added + removed) the
+        // 演进智能体 EVOLVING AGENT's ONE bounded edit may total. Default 40.
+        // Optional/omitted ⇒ the agent's DEFAULT_EVOLVING_AGENT_EDIT_BUDGET applies.
+        editBudget: z.number().optional(),
+        // Loop v2 — 奖励智能体 REWARD AGENT judge-quality knobs. ALL optional; omitted
+        // ⇒ the historical single-sample, flag-only behaviour (no extra LLM spawns).
+        reward: z
+            .object({
+            // ② How many judged duels per episode. Default 1 (single sample, no
+            //   extra spawns). >1 enables the A/A noise floor + SPRT + order-swap.
+            samples: z.number().optional(),
+            // ② Minimum |advantage| to trust; within the floor ⇒ insufficient-signal.
+            //   Omitted ⇒ measured from an A/A pair when samples>1, else unused.
+            noiseFloor: z.number().optional(),
+            // ③ Swap arm presentation order across samples to cancel position bias.
+            orderSwap: z.boolean().optional(),
+            // ① Enforce the correctness hard-gate inside the judge (default on).
+            requireCorrectnessGate: z.boolean().optional(),
+            // ④ Test-tamper handling: 'off' (no check), 'flag' (annotate only,
+            //   default), or 'block' (force insufficient-signal + reject-buffer).
+            tamperCheck: z.enum(['off', 'flag', 'block']).optional(),
+        })
+            .optional(),
+        // Loop v2 — CRITIC AGENT（基线智能体 baseline agent）baseline construction.
+        //   're-do' (default): the baseline arm RE-DOES the change under the prior
+        //     policy vN — it resets the change's GENERATED artifacts (design.md,
+        //     tasks.md), re-authors design under the installed vN template, then
+        //     re-implements → gen-test → run-test. So advantage ＝ reward(主臂) −
+        //     reward(基线臂) reflects the POLICY change, not re-run noise. Faithful
+        //     when the change's implementation is still uncommitted at episode time
+        //     (the workflow default) and an isolated git worktree can be created;
+        //     on a non-git copy fallback it degrades to a re-measure (documented).
+        //   're-test': the prior behaviour — re-run the EXISTING change's tests
+        //     under vN's template (cheaper, but an already-authored change does not
+        //     exercise the design template). Omitted ⇒ 're-do'.
+        critic: z
+            .object({
+            baselineMode: z.enum(['re-test', 're-do']).optional(),
+        })
+            .optional(),
     })
         .optional()
         .describe('Per-canonical-target self-evolution toggles'),
@@ -218,6 +265,55 @@ export function readProjectConfig(projectRoot) {
                         console.warn(`Invalid 'selfEvolution.focus' in config (must be boolean), ignoring`);
                     }
                 }
+                // Loop v2 numeric knobs. Resilient: a non-number is dropped with a
+                // warning (the orchestrator/agent default then applies); omitted ⇒
+                // undefined (byte-identical to configs that never set them).
+                const advThresholdResult = z.number().safeParse(rawSE.advantageRollbackThreshold);
+                if (advThresholdResult.success) {
+                    selfEvolution.advantageRollbackThreshold = advThresholdResult.data;
+                }
+                else if (rawSE.advantageRollbackThreshold !== undefined) {
+                    console.warn(`Invalid 'selfEvolution.advantageRollbackThreshold' in config (must be a number), ignoring`);
+                }
+                const editBudgetResult = z.number().safeParse(rawSE.editBudget);
+                if (editBudgetResult.success) {
+                    selfEvolution.editBudget = editBudgetResult.data;
+                }
+                else if (rawSE.editBudget !== undefined) {
+                    console.warn(`Invalid 'selfEvolution.editBudget' in config (must be a number), ignoring`);
+                }
+                // Loop v2 — 奖励智能体 REWARD AGENT knobs. Resilient: each sub-field is
+                // validated independently; a bad value is dropped with a warning (the
+                // judge/aggregator default applies). Omitted ⇒ undefined (single-sample,
+                // flag-only — byte-identical to configs that never set `reward`).
+                const rewardSchema = ProjectConfigSchema.shape.selfEvolution
+                    .unwrap()
+                    .shape.reward.unwrap();
+                const rewardResult = rewardSchema.safeParse(rawSE.reward);
+                if (rewardResult.success) {
+                    if (Object.keys(rewardResult.data).length > 0) {
+                        selfEvolution.reward = rewardResult.data;
+                    }
+                }
+                else if (rawSE.reward !== undefined) {
+                    console.warn(`Invalid 'selfEvolution.reward' in config (samples/noiseFloor numbers, ` +
+                        `orderSwap/requireCorrectnessGate booleans, tamperCheck off|flag|block), ignoring`);
+                }
+                // Loop v2 — CRITIC AGENT knobs. Resilient: a bad value is dropped with a
+                // warning (the critic default 're-do' then applies). Omitted ⇒ undefined
+                // (byte-identical to configs that never set `critic`).
+                const criticSchema = ProjectConfigSchema.shape.selfEvolution
+                    .unwrap()
+                    .shape.critic.unwrap();
+                const criticResult = criticSchema.safeParse(rawSE.critic);
+                if (criticResult.success) {
+                    if (Object.keys(criticResult.data).length > 0) {
+                        selfEvolution.critic = criticResult.data;
+                    }
+                }
+                else if (rawSE.critic !== undefined) {
+                    console.warn(`Invalid 'selfEvolution.critic' in config (baselineMode must be 're-test' or 're-do'), ignoring`);
+                }
                 config.selfEvolution = selfEvolution;
             }
             else {

package/dist/core/self-evolution/candidate-fitness.d.ts

@@ -1,4 +1,4 @@
-import type { CandidateRepoLayout } from './candidates.js';
+import { type CandidateRepoLayout } from './candidates.js';
 export declare const FITNESS_RECORD_FILE = "fitness-record.jsonl";
 export interface CandidateFitnessRecord {
     /** ISO-8601 UTC timestamp the sample was recorded. */
@@ -44,4 +44,26 @@ export declare function isValidRecord(value: unknown): value is CandidateFitness
  * absent. Malformed/blank lines are skipped (forward-compatible).
  */
 export declare function readCandidateFitness(layout: CandidateRepoLayout, candidateId: string): Promise<AccumulatedFitness>;
+/**
+ * The accumulated baseline reading for a target's de-facto canonical variant:
+ * the promoted candidate whose fitness sidecar supplies the baseline loss.
+ */
+export interface PromotedBaseline {
+    candidateId: string;
+    meanLoss: number;
+    /** createdAt of the baseline candidate (for reporting). */
+    recordedAt: string;
+}
+/**
+ * The de-facto canonical baseline loss for a target: the accumulated mean loss
+ * of the MOST RECENTLY promoted candidate that has measured fitness. Returns
+ * null when no promoted candidate for the target has a non-null meanLoss (⇒
+ * downstream gates cannot use a baseline). Rolled-back candidates are excluded
+ * automatically (they are status 'rolled-back', not 'promoted').
+ *
+ * `listCandidates` already returns promoted candidates sorted by `createdAt`
+ * DESCENDING (ties by id), so the first proven candidate in iteration order is
+ * the most recently promoted one with fitness.
+ */
+export declare function readPromotedBaselineLoss(layout: CandidateRepoLayout, targetId: string): Promise<PromotedBaseline | null>;
 //# sourceMappingURL=candidate-fitness.d.ts.map

package/dist/core/self-evolution/candidate-fitness.js

@@ -1,12 +1,12 @@
 /**
- * Per-candidate accumulated fitness (the GA outer loop's "weight history").
+ * Per-candidate accumulated fitness for the manual promote / evolve-from-edits
+ * channel (a candidate's accumulated outcome history).
  *
  * Each real change a candidate template-variant was active for appends one line
  * to an append-only `fitness-record.jsonl` sidecar in the candidate's directory
- * (`<baseDir>/<candidateId>/fitness-record.jsonl`). The genetic algorithm reads
- * the accumulated record to compare/select among competing variants and to feed
- * a data-driven promotion verdict. See
- * todo/learn-self-evolution-migration-plan.md.
+ * (`<baseDir>/<candidateId>/fitness-record.jsonl`). The manual promote /
+ * evolve-from-edits path reads the accumulated record to feed a data-driven
+ * promotion verdict. See todo/learn-self-evolution-migration-plan.md.
  *
  * Sidecar (not a candidate.json field) on purpose: candidate.json is the stable
  * proposal-time header; fitness is retrospective outcome data that grows over
@@ -15,6 +15,7 @@
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { listCandidates } from './candidates.js';
 export const FITNESS_RECORD_FILE = 'fitness-record.jsonl';
 function candidateDir(layout, candidateId) {
     return path.join(layout.baseDir, candidateId);
@@ -104,4 +105,29 @@ export async function readCandidateFitness(layout, candidateId) {
         recentTrend: trendOf(records.map((r) => r.loss)),
     };
 }
+/**
+ * The de-facto canonical baseline loss for a target: the accumulated mean loss
+ * of the MOST RECENTLY promoted candidate that has measured fitness. Returns
+ * null when no promoted candidate for the target has a non-null meanLoss (⇒
+ * downstream gates cannot use a baseline). Rolled-back candidates are excluded
+ * automatically (they are status 'rolled-back', not 'promoted').
+ *
+ * `listCandidates` already returns promoted candidates sorted by `createdAt`
+ * DESCENDING (ties by id), so the first proven candidate in iteration order is
+ * the most recently promoted one with fitness.
+ */
+export async function readPromotedBaselineLoss(layout, targetId) {
+    const promoted = await listCandidates(layout, { status: 'promoted', targetId });
+    for (const candidate of promoted) {
+        const fitness = await readCandidateFitness(layout, candidate.id);
+        if (fitness.meanLoss !== null) {
+            return {
+                candidateId: candidate.id,
+                meanLoss: fitness.meanLoss,
+                recordedAt: candidate.createdAt,
+            };
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=candidate-fitness.js.map

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

@@ -96,15 +96,6 @@ export interface CanonicalCandidate {
     evalReportPath?: string;
     /** Set by promotion once a decision has been recorded. Relative to candidate dir. */
     promotionDecisionPath?: string;
-    /**
-     * Population-based generation (`propose-canonical --variants N`): the shared id
-     * of the sibling-variant cohort drafted from the SAME hint group in one run.
-     * Absent for single-candidate (default) proposals. Lets the GA outer loop mark
-     * siblings that lost the ranking as `outcompeted`.
-     */
-    variantGroup?: string;
-    /** The improvement angle this variant was asked to pursue (population-based). */
-    variantAngle?: string;
 }
 /**
  * A single full-file-replacement edit produced by the proposer agent: the