synergyspec-selfevolving 1.4.0 → 2.1.0

package/dist/core/self-evolution/tamper-check.js

@@ -0,0 +1,236 @@
+/**
+ * 防作弊 ANTI-HACKING test-tamper detection — a deterministic, dependency-free
+ * detector that flags a 主智能体 MAIN agent which "passed" by weakening its own
+ * tests rather than by making the code correct. The 奖励智能体 REWARD AGENT calls
+ * {@link detectTestTamper} on a change's directory and, when a STRONG heuristic
+ * fires, treats the episode as 作弊嫌疑 tamper-suspected (a hard gate, never a
+ * smooth penalty).
+ *
+ * Three families of heuristic, all read directly off the change dir's files:
+ *   1. Count mismatch — `spec-tests.md` declares N scenarios but `test-report.md`
+ *      collected/ran far fewer (the agent deleted/skipped most of the suite).
+ *   2. Neutered assertions — `assert True`, `assert(true)`, `expect(true).toBe(true)`
+ *      and friends in any discovered test file.
+ *   3. Disabled tests — `pytest.skip`/`@pytest.mark.xfail`/`it.skip`/`t.Skip(` …,
+ *      or an empty test body left as `pass`/`return` with a `TODO`.
+ *
+ * Conservative by construction: every heuristic tolerates missing files (returns
+ * no flag, never throws on ENOENT), the count heuristic only fires on a LARGE
+ * drop, and `suspected` is true iff at least one strong heuristic fired. Output
+ * is bounded so a pathological change cannot flood the caller.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { parseTestMetrics } from '../fitness/test-metrics.js';
+/** Cap on the number of flags returned (the strongest first). */
+const MAX_FLAGS = 6;
+/** Cap on each flag's length. */
+const MAX_FLAG_CHARS = 200;
+/** Report must show at least this fraction of the declared scenarios or it's a drop. */
+const MIN_REPORT_FRACTION = 0.5;
+/** Only fire the count heuristic when the suite is non-trivial. */
+const MIN_DECLARED_FOR_DROP = 4;
+/** Cap on how many test files we scan (a defensive bound). */
+const MAX_TEST_FILES = 400;
+/** Cap on directory recursion depth. */
+const MAX_DEPTH = 8;
+// ANSI SGR sequence matcher — same construction as test-metrics.ts so no
+// literal control character lives in the source.
+const ANSI_SGR = new RegExp(String.fromCharCode(27) + '?\\[[0-9;]*m', 'g');
+function clampFlag(text) {
+    const t = text.trim();
+    return t.length > MAX_FLAG_CHARS ? `${t.slice(0, MAX_FLAG_CHARS - 1)}…` : t;
+}
+/** Read a file as utf8, or return null when it does not exist (never throws on ENOENT). */
+async function readFileOrNull(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        // A directory-where-a-file-was, permission, etc. — treat as "no signal".
+        return null;
+    }
+}
+/**
+ * Count the scenarios/tests a `spec-tests.md` declares. The canonical gen-tests
+ * format is a "Requirement Traceability Matrix" markdown table — one row per
+ * mapped (requirement, test) pair. We count those data rows (skipping the
+ * header + separator and any row whose test cell is "—"/blank, which marks a
+ * step with no applicable test). Returns null when no countable table is found.
+ */
+export function countDeclaredScenarios(specTestsText) {
+    if (!specTestsText)
+        return null;
+    const lines = specTestsText.replace(ANSI_SGR, '').split(/\r?\n/);
+    let count = 0;
+    let sawTableRow = false;
+    for (const raw of lines) {
+        const line = raw.trim();
+        // A markdown table data row: starts and ends with a pipe and has ≥ 3 cells.
+        if (!line.startsWith('|') || !line.endsWith('|'))
+            continue;
+        const cells = line
+            .slice(1, -1)
+            .split('|')
+            .map((c) => c.trim());
+        if (cells.length < 3)
+            continue;
+        // Header separator row: every cell is dashes/colons.
+        if (cells.every((c) => /^:?-{2,}:?$/.test(c) || c === ''))
+            continue;
+        // Header row: a cell literally named "ID" or "Use Case ID" etc. — skip the
+        // first such header but keep scanning for data rows.
+        const firstCell = cells[0].toLowerCase();
+        if (firstCell === 'id' || firstCell === 'use case id' || firstCell === 'uc step') {
+            continue;
+        }
+        sawTableRow = true;
+        count += 1;
+    }
+    return sawTableRow ? count : null;
+}
+/** test-report.md count heuristic: declared N but report collected far fewer. */
+async function checkCountMismatch(changeDirPath) {
+    const specText = await readFileOrNull(path.join(changeDirPath, 'spec-tests.md'));
+    const reportText = await readFileOrNull(path.join(changeDirPath, 'test-report.md'));
+    if (specText === null || reportText === null)
+        return null;
+    const declared = countDeclaredScenarios(specText);
+    if (declared === null || declared < MIN_DECLARED_FOR_DROP)
+        return null;
+    const metrics = parseTestMetrics(reportText);
+    if (metrics === null)
+        return null;
+    const collected = metrics.total;
+    if (collected >= declared * MIN_REPORT_FRACTION)
+        return null;
+    return clampFlag(`spec-tests.md declares ${declared} scenarios but test-report shows ${collected} collected ` +
+        `(< ${Math.round(MIN_REPORT_FRACTION * 100)}% of declared) — most of the suite appears dropped or skipped`);
+}
+/** Neutered/tautological assertion patterns across python/js/ts/go test files. */
+const NEUTERED_ASSERTION_RES = [
+    /\bassert\s+True\b/, // python: assert True
+    /\bassert\s+1\s*==\s*1\b/, // python: assert 1 == 1
+    /\bassert\s*\(\s*true\s*\)/i, // js/go-ish: assert(true)
+    /\bassert\s+(['"]).*\1\b/, // python: assert "msg"  (truthy literal)
+    /\bexpect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*true\s*\)/i, // jest/vitest
+    /\bexpect\s*\(\s*1\s*\)\s*\.\s*toBe\s*\(\s*1\s*\)/i, // jest/vitest: expect(1).toBe(1)
+    /\bassert\.\w+\s*\(\s*true\s*,?\s*true\s*\)/i, // node assert.equal(true,true)
+];
+/** Disabled / skipped test markers across python/js/ts/go. */
+const DISABLED_TEST_RES = [
+    /\bpytest\s*\.\s*skip\b/, // pytest.skip(...)
+    /@\s*pytest\s*\.\s*mark\s*\.\s*skip\b/, // @pytest.mark.skip
+    /@\s*pytest\s*\.\s*mark\s*\.\s*xfail\b/, // @pytest.mark.xfail
+    /@\s*unittest\s*\.\s*skip\b/, // @unittest.skip
+    /\b(?:it|describe|test)\s*\.\s*skip\b/, // it.skip / describe.skip / test.skip
+    /\b(?:xit|xdescribe)\s*\(/, // xit( / xdescribe(
+    /\bt\s*\.\s*Skip\s*\(/, // go: t.Skip(
+];
+const TEST_FILE_RE = /(?:^|[._-])test|test[._-]|\.spec\.|\.test\./i;
+const SCANNABLE_EXT = new Set(['.py', '.ts', '.tsx', '.js', '.jsx', '.go']);
+/** Is this a file we should scan for tampered test code? */
+function looksLikeTestFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!SCANNABLE_EXT.has(ext))
+        return false;
+    const base = path.basename(filePath);
+    return TEST_FILE_RE.test(base);
+}
+/** Walk the change dir (bounded), collecting paths that look like test files. */
+async function collectTestFiles(root) {
+    const found = [];
+    async function walk(dir, depth) {
+        if (depth > MAX_DEPTH || found.length >= MAX_TEST_FILES)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip, never throw
+        }
+        for (const entry of entries) {
+            if (found.length >= MAX_TEST_FILES)
+                return;
+            const name = entry.name;
+            const full = path.join(dir, name);
+            if (entry.isDirectory()) {
+                if (name === 'node_modules' || name === '.git')
+                    continue;
+                await walk(full, depth + 1);
+            }
+            else if (entry.isFile() && looksLikeTestFile(full)) {
+                found.push(full);
+            }
+        }
+    }
+    await walk(root, 0);
+    return found;
+}
+/**
+ * A test body that is just `pass`/`return` paired with a TODO comment — an
+ * empty stub masquerading as a test. We look for a TODO comment on (or right
+ * beside) a lone `pass`/`return` line.
+ */
+const EMPTY_BODY_TODO_RES = [
+    /^\s*(?:pass|return)\b.*(?:#|\/\/)\s*TODO/im, // pass  # TODO  /  return // TODO
+    /(?:#|\/\/)\s*TODO[^\n]*\n\s*(?:pass|return)\b/im, // # TODO\n    pass
+];
+/** Scan the discovered test files for neutered assertions and disabled tests. */
+async function scanTestFiles(root) {
+    const files = await collectTestFiles(root);
+    const scan = { neutered: 0, disabled: 0, emptyTodo: 0 };
+    for (const file of files) {
+        const content = await readFileOrNull(file);
+        if (content === null)
+            continue;
+        const rel = path.relative(root, file) || path.basename(file);
+        if (NEUTERED_ASSERTION_RES.some((re) => re.test(content))) {
+            scan.neutered += 1;
+            if (scan.firstNeuteredFile === undefined)
+                scan.firstNeuteredFile = rel;
+        }
+        if (DISABLED_TEST_RES.some((re) => re.test(content))) {
+            scan.disabled += 1;
+            if (scan.firstDisabledFile === undefined)
+                scan.firstDisabledFile = rel;
+        }
+        if (EMPTY_BODY_TODO_RES.some((re) => re.test(content))) {
+            scan.emptyTodo += 1;
+        }
+    }
+    return scan;
+}
+/**
+ * Detect whether a change's tests were tampered to fake a pass. Reads only
+ * files under `input.changeDirPath`; tolerates every missing file. `suspected`
+ * is true iff at least one strong heuristic fired.
+ */
+export async function detectTestTamper(input) {
+    const root = input.changeDirPath;
+    const flags = [];
+    const countFlag = await checkCountMismatch(root);
+    if (countFlag)
+        flags.push(countFlag);
+    const scan = await scanTestFiles(root);
+    if (scan.neutered > 0) {
+        const where = scan.firstNeuteredFile ? ` (e.g. ${scan.firstNeuteredFile})` : '';
+        flags.push(clampFlag(`${scan.neutered} test file(s) contain trivially-true / neutered assertions` +
+            `${where} — e.g. \`assert True\`, \`expect(true).toBe(true)\``));
+    }
+    if (scan.disabled > 0) {
+        const where = scan.firstDisabledFile ? ` (e.g. ${scan.firstDisabledFile})` : '';
+        flags.push(clampFlag(`${scan.disabled} test file(s) disable tests via skip/xfail/xit${where} — ` +
+            `the suite may pass because its checks no longer run`));
+    }
+    if (scan.emptyTodo > 0) {
+        flags.push(clampFlag(`${scan.emptyTodo} test file(s) have empty test bodies (\`pass\`/\`return\` with a TODO) ` +
+            `standing in for real assertions`));
+    }
+    const capped = flags.slice(0, MAX_FLAGS);
+    return { suspected: capped.length > 0, flags: capped };
+}
+//# sourceMappingURL=tamper-check.js.map

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

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

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

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

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

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

package/dist/core/templates/workflows/gen-tests.js

@@ -72,7 +72,7 @@ const INSTRUCTIONS_BODY = `**Input**: Optionally specify a change name. If omitt
 
    Detection order: scan existing test files for PBT imports first; if none found, infer from project language; if ambiguous, use AskUserQuestion.
 
-   **Every WHEN/THEN scenario extracted in step 4 must have exactly one PBT test** — no exceptions:
+   **Every WHEN/THEN scenario extracted in step 4 must have exactly one PBT test**, with ONE sanctioned exception — a scenario whose behaviour is already exhaustively covered by an existing example/benchmark test AND that cannot be expressed as a meaningful property may instead be recorded as a \`➖ N/A\` row in the PBT Coverage table (step 8), citing that covering test. Otherwise, no exceptions:
    - **WHEN** clause → generator expression + precondition guard (filter/assume)
    - **THEN** clause → invariant (property assertion that must hold for all generated inputs)
    - When the WHEN clause has no parameterisable variable (e.g. "WHEN the app loads"), generate arbitrary system/environment state as the input and use the THEN clause alone as the invariant.

package/dist/core/templates/workflows/learn.d.ts

@@ -2,8 +2,9 @@
  * Skill Template Workflow Modules
  *
  * Learn workflow: thin entrance to self-evolution — selects the change,
- * spawns the fresh-context critic skill
- * (synergyspec-selfevolving-self-evolving), and relays its verdict.
+ * spawns the fresh-context runner skill
+ * (synergyspec-selfevolving-self-evolving), which triggers ONE loop-v2
+ * self-evolution episode, and relays its verdict.
  */
 import type { SkillTemplate, CommandTemplate } from '../types.js';
 export declare function getLearnSkillTemplate(): SkillTemplate;

package/dist/core/templates/workflows/learn.js

@@ -2,7 +2,7 @@ const INSTRUCTIONS_BODY = `**Input**: Optionally specify a change name. If omitt
 
 **Purpose**
 
-This is the review-and-learn step after \`/synspec:apply\` and \`/synspec:verify\`, and it is the ENTRANCE to autonomous self-evolution — but the critique itself runs in a FRESH-CONTEXT critic subagent (\`synergyspec-selfevolving-self-evolving\`). The rollout actor does not grade its own work: end-of-cycle sessions are context-heavy, and the system grades the on-disk trajectory, not the actor's intentions. Your job here is to select the change, hand the critic explicit handles, and relay its verdict.
+This is the review-and-learn step after \`/synspec:apply\` and \`/synspec:verify\`, and it is the ENTRANCE to one self-evolution EPISODE (loop v2 — self-evolution as in-context RL) — but the episode itself runs through a FRESH-CONTEXT runner subagent (\`synergyspec-selfevolving-self-evolving\`). The rollout actor does not grade its own work: end-of-cycle sessions are context-heavy, and the system grades the on-disk trajectory, not the actor's intentions. The runner does not grade or edit either — it triggers the CLI episode orchestrator, which CODE-SPAWNS the 奖励智能体 REWARD AGENT (scoring) and 演进智能体 EVOLVING AGENT (the ONE bounded edit onto the 策略 POLICY), then relays the result. Your job here is to select the change, hand the runner explicit handles, and relay its verdict.
 
 **Steps**
 
@@ -12,41 +12,44 @@ This is the review-and-learn step after \`/synspec:apply\` and \`/synspec:verify
    - Infer from conversation context only if the change is unambiguous
    - If ambiguous, run \`synergyspec-selfevolving list --json\` and ask the user to select
 
-   Prefer changes that have completed apply/verify evidence. If apply or verify appears incomplete, continue in preview mode and clearly mark the missing evidence.
+   Prefer changes that have completed apply/verify evidence. If apply or verify appears incomplete, continue and clearly mark the missing evidence — the orchestrator's 奖励智能体 REWARD AGENT will 弃权 abstain rather than score on absent evidence.
 
 2. **Gather explicit handles**
 
-   The critic starts with NO conversation context, so collect every handle it needs:
+   The runner starts with NO conversation context, so collect every handle it needs:
    - **Project root**: the absolute path of the current working directory.
    - **Change name**: from step 1.
    - **Harness**: read the \`harness:\` key from \`synergyspec-selfevolving/changes/<name>/.synergyspec-selfevolving.yaml\`; if absent, use \`unknown\`.
-   - **Mode**: \`preview\` only if the user asked for a preview; otherwise \`apply\` (the critic consolidates memory and runs the gated \`evolve-from-edits … --yes\` promote autonomously — no confirmation prompt).
-   - **Session handle (optional)**: if your harness exposes this session's id or transcript path, capture it; otherwise omit it (trajectory discovery then uses the change window).
+   - **Mode**: always \`apply\` — the episode runs the full loop (score, decide, and the 演进智能体's ONE bounded edit) autonomously, with no confirmation prompt. There is NO read-only episode and NO \`--preview\` flag. If the user wants a read-only look (no rollback, no evolution), do NOT run an episode: use the read-only view \`synergyspec-selfevolving self-evolution policy show\` (or a plain \`synergyspec-selfevolving learn <name>\` without \`--apply\`) instead.
+   - **Session handle (optional)**: if your harness exposes this session's id or transcript path, capture it; otherwise omit it (the 主智能体 MAIN AGENT arm's trajectory discovery then uses the change window).
 
-3. **Spawn the critic**
+3. **Spawn the runner**
 
-   Use Task tool (subagent_type: "general-purpose", prompt: "Use Skill tool to invoke synergyspec-selfevolving-self-evolving for change '<name>'. Project root: <root>. Harness: <harness>. Mode: <apply|preview>. Session-id: <id>. Transcript: <path>. Run the full critique autonomously, do not ask the user questions, and end with the '## Critic Verdict' block.")
+   Use Task tool (subagent_type: "general-purpose", prompt: "Use Skill tool to invoke synergyspec-selfevolving-self-evolving for change '<name>'. Project root: <root>. Harness: <harness>. Mode: apply. Session-id: <id>. Transcript: <path>. Trigger the loop-v2 self-evolution episode autonomously, do not ask the user questions, and end with the '## Episode Verdict' block.")
 
    Include the \`Session-id: <id>.\` / \`Transcript: <path>.\` segment only when the session handle from step 2 is known — omit it entirely when unknown.
 
+   The runner triggers exactly one CLI command — \`synergyspec-selfevolving self-evolution episode --change "<name>" --session-id <id>\` — and the orchestrator CODE-SPAWNS the 奖励智能体 REWARD AGENT + 演进智能体 EVOLVING AGENT (+ optional CRITIC AGENT（基线智能体）). Neither you nor the runner grades or edits canonical files.
+
    Guardrails:
-   - Do NOT perform the critique steps yourself in this session — the critique must run in a fresh context.
-   - **Fallback (no Task tool):** if this host has no Task tool (or spawning fails), invoke the synergyspec-selfevolving-self-evolving skill INLINE instead — use the Skill tool, or read \`<skillsDir>/skills/synergyspec-selfevolving-self-evolving/SKILL.md\` and follow it in this session — and note \`Isolation: inline fallback (degraded)\` in the final output.
-   - **Last resort (critic skill not installed):** run \`synergyspec-selfevolving learn "<name>" --preview\`, report that the full critique could not run, and suggest re-running \`synergyspec-selfevolving init\`.
+   - Do NOT trigger the episode yourself in this session — it must run from a fresh context.
+   - **Fallback (no Task tool / runner never started):** ONLY when this host has no Task tool, or the spawn never produced a \`## Episode Verdict\` block at all, invoke the synergyspec-selfevolving-self-evolving skill INLINE instead — use the Skill tool, or read \`<skillsDir>/skills/synergyspec-selfevolving-self-evolving/SKILL.md\` and follow it in this session — and note \`Isolation: inline fallback (degraded)\` in the final output.
+   - **STOP — do NOT retry inline — when the runner DID return a verdict whose Outcome is \`error-...\`** (the episode command itself ran and failed — e.g. \`error-ENAMETOOLONG\`). An inline re-run invokes the SAME failing CLI and fails identically. Surface it as a DEFECT to the user, do NOT archive over it, and stop.
+   - **Last resort (runner skill not installed):** run \`synergyspec-selfevolving self-evolution episode --change "<name>"\`, report that the full episode could not run via the runner, and suggest re-running \`synergyspec-selfevolving init\`.
 
 4. **Verify and relay the verdict**
 
-   Read the critic's \`## Critic Verdict\` block from its final message, then:
-   - Cross-check it against \`synergyspec-selfevolving status --change "<name>" --json\` and \`synergyspec-selfevolving/changes/<name>/evolution-result.json\`. NEVER contradict the machine-written outcome.
-   - Relay the outcome, the evolved target, and the rollback command verbatim.
-   - Classify any refusal before moving on: a SAFE refusal (missing/red evidence, frozen target, static gate failed on real grounds) is expected, not a bug; a DEFECT the critic flagged (an unbindable target, a promotion failure that is NOT about evidence / freezing / scope) must be surfaced to the user, not archived over. \`Outcome: not-run\` is a safe no-op (no hints survived, or no bindable target) — not a DEFECT, unless the critic flagged case-(b). On a verified-GREEN run, learn also records success-channel protections/exemplars as side-writes — proposing nothing on a green run is the CORRECT outcome, not a missed evolution.
+   Read the runner's \`## Episode Verdict\` block from its final message, then:
+   - Cross-check it against \`synergyspec-selfevolving status --change "<name>" --json\` and the episode's \`episode.json\` / \`diagnosis.json\`. NEVER contradict the machine-written outcome.
+   - Relay the outcome, the decision (rolled-back / kept / abstained), the evolution kind, the new 策略 POLICY version, the evolved target, and the rollback command verbatim.
+   - Classify the outcome before moving on: a \`kept\` / \`abstained\` no-op on a verified-green or no-nameable-gap run is the CORRECT outcome (产物即弃), not a missed evolution; a \`rolled-back\` decision is the loop working (the 否决缓冲 reject-buffer recorded the lost direction). A SAFE refusal (missing/red evidence, frozen target, gate refused on real grounds) is expected, not a bug; a DEFECT the runner flagged (an unbindable target, an orchestrator failure that is NOT about evidence / freezing / scope) must be surfaced to the user, not archived over.
 
 **Output Format**
 
-- Lead with the critic's verdict, not the spawn mechanics.
-- Relay the \`## Critic Verdict\` fields verbatim: outcome, evolved target, canonical file(s) changed, and the rollback command.
-- State clearly whether anything was written (memory, learn report, canonical promote) and the isolation mode (fresh-context subagent, or inline fallback (degraded)).
-- Separate safe refusals from DEFECTs to surface.
+- Lead with the runner's verdict, not the spawn mechanics.
+- Relay the \`## Episode Verdict\` fields verbatim: outcome, decision, evolution kind, advantage, new 策略 POLICY version, evolved target, canonical file(s) changed, and the rollback command.
+- State clearly whether the 策略 POLICY changed (evolved / rolled-back / unchanged) and the isolation mode (fresh-context subagent, or inline fallback (degraded)).
+- Separate safe no-ops and refusals from DEFECTs to surface.
 - End with the normal next step: \`/synspec:archive\` once the user is satisfied with the review.`;
 export function getLearnSkillTemplate() {
     return {

package/dist/core/templates/workflows/self-evolving.d.ts

@@ -1,10 +1,12 @@
 /**
  * Skill Template Workflow Modules
  *
- * Self-evolving critic: utility skill (no command counterpart) — always
- * installed regardless of profile. Fresh-context critic for a completed
- * change; normally spawned by synergyspec-selfevolving-learn (the rollout
- * actor) so the critique never runs in the actor's own context.
+ * Self-evolving runner: utility skill (no command counterpart) — always
+ * installed regardless of profile. In loop v2 (self-evolution as in-context
+ * RL) the 奖励智能体 REWARD AGENT (scoring) and 演进智能体 EVOLVING AGENT
+ * (editing) are CODE-SPAWNED by the episode orchestrator — so this host-facing
+ * skill is a THIN RUNNER: it triggers the CLI episode and relays the result.
+ * It NEVER grades and NEVER edits canonical files itself.
  */
 import type { SkillTemplate } from '../types.js';
 export declare function getSelfEvolvingSkillTemplate(): SkillTemplate;