synergyspec-selfevolving 1.4.0 → 2.0.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/project-config.d.ts

@@ -25,6 +25,8 @@ 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>;
     }, z.core.$strip>>;
     health: z.ZodOptional<z.ZodObject<{
         source: z.ZodDefault<z.ZodEnum<{

package/dist/core/project-config.js

@@ -49,6 +49,17 @@ 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(),
     })
         .optional()
         .describe('Per-canonical-target self-evolution toggles'),
@@ -218,6 +229,23 @@ 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`);
+                }
                 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

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

@@ -0,0 +1,150 @@
+/**
+ * CRITIC AGENT（基线智能体 baseline agent）runner — loop v2 (self-evolution as
+ * in-context RL).
+ *
+ * The CRITIC AGENT is an AGENT with the SAME input/output as the 主智能体 MAIN
+ * AGENT (frozen actor; the user's host agent running the current 策略 policy
+ * vN+1). It reruns LAST episode's 策略 policy vN on the SAME change in an
+ * ISOLATED worktree, so the 奖励智能体 REWARD AGENT can later 算分 calculate
+ * reward(主臂)＆reward(基线臂) and advantage ＝ reward(主臂) − reward(基线臂).
+ * Only its baseline trajectory survives — 产物即弃 (worktree artifacts
+ * discarded): the worktree is torn down in `finally`, and the single durable
+ * output is the `baseline-arm/` capture in the episode store.
+ *
+ * This module orchestrates ONE baseline arm:
+ *   1. create an isolated worktree OUTSIDE the repo (git worktree, else a
+ *      recursive file copy fallback),
+ *   2. make it runnable (node_modules junction/symlink + the untracked surfaces
+ *      the rerun reads),
+ *   3. INSTALL 策略 policy vN into the worktree from the byte-for-byte version
+ *      snapshot, so the baseline arm reruns the PRIOR policy and not the live
+ *      templates,
+ *   4. rerun headlessly via the host-aware {@link runHeadlessAgent} with
+ *      cwd = worktree, measurement only, never editing canonical files,
+ *   5. persist the baseline arm (stdout always; the claude session transcript +
+ *      action skeleton when discoverable; an `objective.json` shaped IDENTICALLY
+ *      to the main arm's), and
+ *   6. ALWAYS tear the worktree down.
+ *
+ * Honesty contract: a pass rate is parse-or-throw — when the rerun's stdout
+ * carries no parseable test summary the objective records `passRate: null`
+ * rather than fabricating one. The agent is RUN, never asked to edit; the prompt
+ * strips every arm/candidate word.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+/** Error thrown when the worktree could not be created (git AND copy fallback failed). */
+export declare class CriticWorktreeError extends Error {
+    constructor(message: string);
+}
+/**
+ * The baseline arm's `objective.json` shape — kept IDENTICAL to the main arm's
+ * (CS4 writes the main arm with this same shape). It mirrors the slice of the
+ * 主智能体 MAIN AGENT's `learn` fitness sample the 奖励智能体 REWARD AGENT
+ * compares across arms:
+ *   - `passRate`       — functional pass rate in [0,1], or `null` when the rerun
+ *                        produced no parseable test summary (NEVER fabricated).
+ *   - `testsTotal` /   — raw counts behind the pass rate, present only when a
+ *     `testsFailed`      summary parsed.
+ *   - `healthPenalty`  — normalized code-health penalty in [0,1] measured
+ *                        against the WORKTREE, or `null` when no signal.
+ *   - `loss`           — blended functional⊕health per-change loss in [0,1], or
+ *                        `null` when there was no functional signal (no pass
+ *                        rate ⇒ "no signal", not loss = 1).
+ *   - `verified`       — whether a real test-runner invocation was OBSERVED in
+ *                        the rerun's trajectory (the observed-verified gate's
+ *                        signal); `false` when only stdout was captured.
+ *   - `observedStatus` — 'success' | 'failure' | null, derived from the observed
+ *                        run (null when no runner was observed).
+ *   - `measuredAt`     — ISO-8601 UTC timestamp the arm was scored.
+ */
+export interface ArmObjective {
+    passRate: number | null;
+    testsTotal?: number;
+    testsFailed?: number;
+    healthPenalty: number | null;
+    loss: number | null;
+    verified: boolean;
+    observedStatus: 'success' | 'failure' | null;
+    measuredAt: string;
+}
+export interface ShouldRunCriticAgentOptions {
+    repoRoot: string;
+    targetId: string;
+}
+export interface ShouldRunCriticAgentResult {
+    /** True when the baseline arm SHOULD run. */
+    run: boolean;
+    /** Human-readable explanation (logged; surfaced on the skip path). */
+    reason: string;
+    /**
+     * The policy version the baseline arm would rerun (LAST episode's vN), or
+     * `null` on every skip path.
+     */
+    baselineVersion: number | null;
+}
+/**
+ * Decide whether the CRITIC AGENT（基线智能体 baseline agent）should run for the
+ * NEXT episode.
+ *
+ * Skip (`run: false`) when:
+ *   - the 单一血统 single lineage has < 2 versions — there is no PRIOR policy to
+ *     rerun (v0 is the only point; the 主智能体 MAIN AGENT IS v0), OR
+ *   - the head 版本账本 ledger entry's action is 'refused' — the 演进智能体
+ *     EVOLVING AGENT refused last episode, so vN+1 ≡ vN and rerunning the
+ *     baseline would compare a policy against ITSELF (no advantage to measure).
+ *
+ * Otherwise run, rerunning the head version (vN, the policy the LAST episode
+ * settled on, which the current 主智能体 MAIN AGENT also runs as vN+1 unless an
+ * evolve happened — the comparison the 奖励智能体 REWARD AGENT scores).
+ *
+ * Pure read of the ledger via {@link readPolicyLedger}/{@link currentPolicyVersion};
+ * this function NEVER writes episode state. The skip path's
+ * {@link advanceEpisodeStage} to 'baseline-skipped' is the CALLER's job.
+ */
+export declare function shouldRunCriticAgent(opts: ShouldRunCriticAgentOptions): Promise<ShouldRunCriticAgentResult>;
+/**
+ * Assemble the CRITIC AGENT（基线智能体 baseline agent）rerun prompt. STRIPPED
+ * of every arm/candidate word: the agent is simply told to re-run change
+ * <changeName> end-to-end (apply → gen-test → run-test) under the templates
+ * already installed in its working directory, measurement only, never editing
+ * canonical files, and to print the runner summary line verbatim as its final
+ * line.
+ */
+export declare function assembleCriticPrompt(changeName: string): string;
+export interface RunCriticAgentOptions {
+    repoRoot: string;
+    targetId: string;
+    changeName: string;
+    episodeId: string;
+    /** LAST episode's policy version vN, from {@link shouldRunCriticAgent}. */
+    baselineVersion: number;
+    /** Injectable spawn seam for tests; defaults to node's spawn. */
+    spawn?: typeof nodeSpawn;
+    /** Hard timeout per agent run (ms). Default 600000 (10 min). */
+    timeoutMs?: number;
+    /** Override `os.homedir()` for tests (claude transcript discovery). */
+    homeDir?: string;
+    /** TEST seam: inject the worktree root instead of git/copy, skipping setup teardown of git. */
+    now?: Date;
+}
+export interface RunCriticAgentResult {
+    /** Absolute path of the `baseline-arm/` dir the capture landed in. */
+    armDir: string;
+    /** The objective that was persisted. */
+    objective: ArmObjective;
+    /** True when the claude session transcript was discovered and persisted. */
+    transcriptDiscovered: boolean;
+    /** The worktree path that was created then discarded (audit only). */
+    worktreePath: string;
+    /** How the worktree was created. */
+    worktreeMode: 'git-worktree' | 'copy-fallback';
+}
+/**
+ * Run the CRITIC AGENT（基线智能体 baseline agent）'s full baseline arm and
+ * persist its capture. ALWAYS tears the worktree down (产物即弃). On success it
+ * advances the episode to 'baseline-arm-captured' (patch
+ * `{policyVersionBaseline}`). The SKIP path is the caller's job (see
+ * {@link shouldRunCriticAgent}).
+ */
+export declare function runCriticAgent(opts: RunCriticAgentOptions): Promise<RunCriticAgentResult>;
+//# sourceMappingURL=critic-agent.d.ts.map