iterate-plugin 3.5.3 → 3.5.4

package/dist/tools/prune.js

@@ -13,6 +13,10 @@
  *   - Empty fix rounds (rounds with 0 records).
  *   - Stray temp files left behind by a crashed atomic write (see
  *     `isPrunableTemp` for the recognized naming conventions).
+ *   - Experience bank entries beyond `MAX_EXPERIENCE_ENTRIES` (newest kept) —
+ *     the bank grows across sessions with no natural bound; a sweep caps it.
+ *   - Defense events older than `retainDays` (stale iteration streams that
+ *     were never cleared).
  *
  * Security model:
  *   - Only operates under the resolved project `.iterate/` directory.
@@ -26,11 +30,22 @@ import { resolveProjectRootForExec } from "../config-loader.js";
 import { writeTextAtomic, writeJsonAtomic } from "../atomic-fs.js";
 import { readDecisionEntries, appendDecisionEntry } from "./decision-log.js";
 import { readRegistry, recomputeRoundCounts } from "./fix.js";
+import { readExperienceBank, writeExperienceBank } from "./experience-store.js";
+import { readDefenseEvents, writeDefenseEvents } from "./defense-store.js";
 import { iterateDir, fixesDir, checkpointPath, fixRegistryPath } from "../paths.js";
 /** Default retention for decision-log entries (in days). */
 const DEFAULT_RETAIN_DAYS = 30;
 const MIN_RETAIN_DAYS = 1;
 const MAX_RETAIN_DAYS = 365;
+/**
+ * Upper bound on experience-bank entries retained by a prune sweep. The bank
+ * accumulates curated knowledge across sessions and each entry is small, so a
+ * generous cap drops only the oldest tail of a pathologically large bank
+ * (never recent learning).
+ */
+export const MAX_EXPERIENCE_ENTRIES = 2000;
+/** How many compare-and-append retries bound the decision-log rewrite race. */
+const MAX_LOG_REWRITE_RETRIES = 3;
 /** Clamp retainDays to a sane range. */
 export function clampRetainDays(days) {
     if (typeof days !== 'number' || !Number.isInteger(days) || days <= 0) {
@@ -66,6 +81,59 @@ export function isPrunableTemp(name) {
     // .<basename>.tmp-<pid>-<rand>: starts with a dot and contains ".tmp-" after it.
     return name.startsWith('.') && name.includes('.tmp-');
 }
+/**
+ * Bound the experience bank to its newest `cap` entries (by timestamp; ties
+ * keep their original order via stable sort). Returns the trimmed bank plus
+ * how many entries would be dropped. Never mutates the input bank.
+ */
+export function sweepExperienceBank(bank, cap) {
+    const size = Number.isFinite(cap) && cap >= 0 ? Math.floor(cap) : MAX_EXPERIENCE_ENTRIES;
+    const total = bank.entries.length;
+    if (total <= size)
+        return { bank, removed: 0 };
+    const kept = [...bank.entries]
+        .sort((a, b) => (b.timestamp ?? '').localeCompare(a.timestamp ?? ''))
+        .slice(0, size);
+    // Preserve the original (insertion) order of the surviving entries.
+    const keptIds = new Set(kept.map((e) => e.id));
+    const ordered = bank.entries.filter((e) => keptIds.has(e.id));
+    return {
+        bank: { ...bank, entries: ordered, lastUpdated: new Date().toISOString() },
+        removed: total - ordered.length,
+    };
+}
+/**
+ * Drop defense events older than `cutoff` from the stream using an ISO
+ * timestamp comparison, recomputing the counts so they can never drift from
+ * the surviving events. Never mutates the input stream.
+ */
+export function sweepDefenseEvents(stream, cutoff) {
+    const kept = stream.events.filter((e) => e.timestamp >= cutoff);
+    if (kept.length === stream.events.length)
+        return { stream, removed: 0 };
+    return {
+        stream: {
+            events: kept,
+            lastUpdated: new Date().toISOString(),
+            counts: computeDefenseCounts(kept),
+        },
+        removed: stream.events.length - kept.length,
+    };
+}
+/** Recompute per-type defense counts from a list of events. */
+function computeDefenseCounts(events) {
+    const counts = {
+        precondition_failed: 0,
+        rollback: 0,
+        invariant_violated: 0,
+        assumption_falsified: 0,
+    };
+    for (const e of events) {
+        if (e.type in counts)
+            counts[e.type]++;
+    }
+    return counts;
+}
 /**
  * Inspect the runtime state and report what would be pruned.
  * Pure (no deletions). Returns a structured report.
@@ -124,6 +192,15 @@ export function inspectPrune(projectRoot, retainDays) {
         iterateEntries = [];
     }
     const staleTemps = iterateEntries.filter((f) => isPrunableTemp(f)).sort();
+    // 6. Experience-bank oversize (entries beyond the entry cap). The bank grows
+    // across sessions with no natural bound — a sweep reports the tail that a
+    // prune would drop (newest `MAX_EXPERIENCE_ENTRIES` preserved).
+    const bank = readExperienceBank(projectRoot);
+    const sweptBank = sweepExperienceBank(bank, MAX_EXPERIENCE_ENTRIES);
+    // 7. Defense events older than retainDays (a previous iteration's stream
+    // that was never cleared).
+    const defenseStream = readDefenseEvents(projectRoot);
+    const sweptDefense = sweepDefenseEvents(defenseStream, cutoff);
     return {
         oldLogEntries,
         hasCheckpoint,
@@ -132,12 +209,57 @@ export function inspectPrune(projectRoot, retainDays) {
         emptyRounds,
         totalLogEntries: entries.length,
         registryRounds: registry.rounds.length,
+        totalExperiences: bank.entries.length,
+        experienceOversize: sweptBank.removed,
+        totalDefenseEvents: defenseStream.events.length,
+        staleDefenseEvents: sweptDefense.removed,
     };
 }
 /**
  * Actually prune the runtime artifacts (only called when dryRun=false).
  * Returns a detailed report of what was deleted.
  */
+/**
+ * Rewrite the decision log to the entries younger than `cutoff`.
+ *
+ * The read-before-rewrite is a TOCTOU hot spot: a concurrent worker can append
+ * a fresh audit line between our read and our atomic rewrite, and an atomic
+ * rename would silently discard it. So instead of a single read+write we use a
+ * bounded compare-and-append loop — after each rewrite we re-read the log and
+ * retry whenever the file grew (a concurrent append slipped in). The loop
+ * terminates when the file is stable or after `MAX_LOG_REWRITE_RETRIES`, and a
+ * failure here is surfaced as a structured error instead of truncating the log.
+ *
+ * @returns the number of entries removed (best-effort) or 0 on error.
+ */
+function rewriteDecisionLogKeepingRecent(projectRoot, cutoff) {
+    const logPath = join(iterateDir(projectRoot), 'decision-log.jsonl');
+    for (let attempt = 0; attempt < MAX_LOG_REWRITE_RETRIES; attempt++) {
+        try {
+            const entries = readDecisionEntries(projectRoot);
+            const kept = entries.filter((e) => e.timestamp >= cutoff);
+            const deleted = entries.length - kept.length;
+            if (deleted === 0)
+                return { deleted: 0 };
+            writeTextAtomic(logPath, kept.map((e) => JSON.stringify(e)).join('\n') + '\n');
+            // A concurrent appender may have landed new lines after our read. If the
+            // log grew during the write window, re-read and prune again instead of
+            // accepting a lost audit trail.
+            const after = readDecisionEntries(projectRoot);
+            if (after.length <= kept.length)
+                return { deleted };
+        }
+        catch (err) {
+            return { deleted: 0, error: `failed to rewrite decision log: ${String(err)}` };
+        }
+    }
+    return { deleted: 0, error: `failed to rewrite decision log after ${MAX_LOG_REWRITE_RETRIES} attempts` };
+}
+/**
+ * Execute the prune: apply every cleanable item reported by `inspectPrune`.
+ * Every step is individually hedged so a single disk failure degrades to a
+ * reported error rather than aborting the whole cleanup.
+ */
 export function executePrune(projectRoot, retainDays, report) {
     const cutoff = cutoffTimestamp(retainDays);
     const result = {
@@ -146,22 +268,19 @@ export function executePrune(projectRoot, retainDays, report) {
         deletedBackups: [],
         deletedTemps: [],
         trimmedEmptyRounds: 0,
+        deletedExperiences: 0,
+        deletedDefenseEvents: 0,
         errors: [],
     };
     // 1. Rewrite the decision log, keeping only recent entries. Atomic
-    // (temp + rename) so a crash mid-write can never truncate the log.
-    try {
-        const entries = readDecisionEntries(projectRoot);
-        const kept = entries.filter((e) => e.timestamp >= cutoff);
-        result.deletedLogEntries = entries.length - kept.length;
-        if (result.deletedLogEntries > 0) {
-            const logPath = join(iterateDir(projectRoot), 'decision-log.jsonl');
-            writeTextAtomic(logPath, kept.map((e) => JSON.stringify(e)).join('\n') + '\n');
-        }
-    }
-    catch (err) {
-        result.errors.push(`failed to rewrite decision log: ${String(err)}`);
-        result.deletedLogEntries = 0;
+    // (temp + rename) so a crash mid-write can never truncate the log; the
+    // bounded compare-and-append loop guards against a concurrent appender
+    // slipping a fresh audit line into the read-before-rewrite window.
+    {
+        const { deleted, error } = rewriteDecisionLogKeepingRecent(projectRoot, cutoff);
+        result.deletedLogEntries = deleted;
+        if (error)
+            result.errors.push(error);
     }
     // 2. Remove checkpoint.
     if (report.hasCheckpoint) {
@@ -213,6 +332,34 @@ export function executePrune(projectRoot, retainDays, report) {
             result.errors.push(`failed to delete temp file ${tmp}: ${String(err)}`);
         }
     }
+    // 6. Trim the experience bank to its entry cap (newest wins).
+    if (report.experienceOversize > 0) {
+        try {
+            const bank = readExperienceBank(projectRoot);
+            const { bank: swept, removed } = sweepExperienceBank(bank, MAX_EXPERIENCE_ENTRIES);
+            if (removed > 0) {
+                writeExperienceBank(projectRoot, swept);
+                result.deletedExperiences = removed;
+            }
+        }
+        catch (err) {
+            result.errors.push(`failed to trim experience bank: ${String(err)}`);
+        }
+    }
+    // 7. Drop defense events older than retainDays (recounted on write).
+    if (report.staleDefenseEvents > 0) {
+        try {
+            const stream = readDefenseEvents(projectRoot);
+            const { stream: swept, removed } = sweepDefenseEvents(stream, cutoff);
+            if (removed > 0) {
+                writeDefenseEvents(projectRoot, swept);
+                result.deletedDefenseEvents = removed;
+            }
+        }
+        catch (err) {
+            result.errors.push(`failed to sweep defense events: ${String(err)}`);
+        }
+    }
     return result;
 }
 /**
@@ -226,7 +373,8 @@ export function registerPruneTool(ctx) {
         description: 'Inspect or clean up old iterate runtime artifacts (.iterate/). ' +
             'Defaults to dry-run (report-only, no deletion). Pass `dryRun: false` to actually prune. ' +
             'Manages: old decision-log entries, stale checkpoints, orphaned fix backups, empty fix rounds, ' +
-            'and stray temp files left by crashed atomic writes. ' +
+            'stray temp files left by crashed atomic writes, experience-bank entries beyond the entry cap, ' +
+            'and stale defense events. ' +
             'Each deletion is logged to the decision log.',
         parameters: {
             dryRun: {
@@ -268,6 +416,8 @@ export function registerPruneTool(ctx) {
                         `  Stale backups to delete: ${report?.staleBackups?.length ?? 0}`,
                         `  Stray temp files to delete: ${report?.staleTemps?.length ?? 0}`,
                         `  Empty rounds to trim: ${report?.emptyRounds?.length ?? 0}`,
+                        `  Experience entries to drop (over ${report?.totalExperiences ?? '?'} cap): ${report?.experienceOversize ?? 0} of ${report?.totalExperiences ?? '?'}`,
+                        `  Stale defense events to remove: ${report?.staleDefenseEvents ?? 0} (of ${report?.totalDefenseEvents ?? '?'})`,
                         '',
                         'Pass dryRun:false to execute the prune.',
                     ];
@@ -280,6 +430,8 @@ export function registerPruneTool(ctx) {
                     `  Deleted ${result?.deletedBackups?.length ?? 0} stale backups.`,
                     `  Deleted ${result?.deletedTemps?.length ?? 0} stray temp files.`,
                     `  Trimmed ${result?.trimmedEmptyRounds ?? 0} empty rounds.`,
+                    `  Trimmed ${result?.deletedExperiences ?? 0} experience entries (over the entry cap).`,
+                    `  Removed ${result?.deletedDefenseEvents ?? 0} stale defense events.`,
                 ];
                 const errs = result?.errors ?? [];
                 if (errs.length > 0) {
@@ -319,6 +471,8 @@ export function registerPruneTool(ctx) {
                     deletedCheckpoint: result.deletedCheckpoint,
                     deletedBackups: result.deletedBackups.length,
                     trimmedEmptyRounds: result.trimmedEmptyRounds,
+                    deletedExperiences: result.deletedExperiences,
+                    deletedDefenseEvents: result.deletedDefenseEvents,
                 },
             });
             return {

package/dist/tools/review.js

@@ -229,9 +229,23 @@ export function registerReviewTool(ctx) {
                     const coverageEnabled = config.reviewer?.coverage_validation !== false;
                     let coverage = null;
                     if (coverageEnabled) {
-                        const assigned = collectScopeFiles(projectRoot, {
-                            scope: config.review?.scope === 'changed-only' ? 'changed-only' : 'full',
-                        });
+                        // Build the assigned inventory the SAME way `plan` builds it: a
+                        // changed-only scope uses the resolved git-diff file set, and
+                        // falls back to the FULL walk when git is unavailable or nothing
+                        // changed (mirrors buildReviewPlan's effective-scope decision), so
+                        // the coverage ratio reflects the files reviewers were actually
+                        // told to read — never a vacuous 1.0 on an empty inventory.
+                        let assigned;
+                        if (config.review?.scope === 'changed-only') {
+                            const gitScope = await resolveChangedFiles(projectRoot, config.git?.target_branch ?? 'main');
+                            assigned =
+                                gitScope.changedFiles.length > 0
+                                    ? collectScopeFiles(projectRoot, { scope: 'changed-only', changedFiles: gitScope.changedFiles })
+                                    : collectScopeFiles(projectRoot, { scope: 'full' });
+                        }
+                        else {
+                            assigned = collectScopeFiles(projectRoot, { scope: 'full' });
+                        }
                         const readFiles = Array.isArray(source.readFiles)
                             ? source.readFiles
                             : null;

package/dist/tools/transcript.js

@@ -148,6 +148,7 @@ export function registerTranscriptTool(ctx) {
                 description: 'For `capture`: array of applied fixes [{id, file, round, summary, linesAdded, linesRemoved, success}].',
             },
             refReadFiles: { type: 'json', description: 'For `capture`: flat array of all read files across rounds (optional).' },
+            stoppedReason: { type: 'string', description: 'For `capture`: why the run ended — "converged" | "max_rounds_reached" | "aborted_by_validation". When omitted, derived from the convergence trend (trailing 0 = converged, otherwise = max_rounds_reached once a round ran).' },
             text: { type: 'string', description: 'For `nudge`: steering text to set (or null to clear).' },
             path: { type: 'string', description: 'Project root directory (default: current working directory).' },
         },
@@ -218,14 +219,25 @@ export function registerTranscriptTool(ctx) {
                 }
                 // Rehydrating a parsed-but-malformed manifest (e.g. `rounds: [null]`
                 // or a non-object) must never crash the nudge — degrade to a fresh
-                // builder so the steering text still lands.
+                // builder so the steering text still lands. The fallback must keep
+                // the ORIGINAL run identity (mode/taskMode/goal/maxRounds) so a
+                // stray malformed field can never silently rewrite a dry-run run
+                // into a `normal` one.
+                const fallbackOpts = {
+                    project: projectRoot,
+                    mode: (manifest?.mode === 'dry-run' || manifest?.mode === 'normal' ? manifest.mode : null),
+                    taskMode: (manifest?.taskMode === 'code' || manifest?.taskMode === 'iterate' ? manifest.taskMode : null),
+                    approval,
+                    goal: typeof manifest?.goal === 'string' ? manifest.goal : '',
+                    maxRounds: typeof manifest?.maxRounds === 'number' ? manifest.maxRounds : 0,
+                };
                 let builder;
                 if (manifest) {
                     try {
                         builder = rehydrateBuilder(manifest, approval);
                     }
                     catch {
-                        builder = new ReviewTranscriptBuilder({ project: projectRoot, mode: 'normal', approval });
+                        builder = new ReviewTranscriptBuilder(fallbackOpts);
                     }
                 }
                 else {
@@ -292,10 +304,20 @@ export function registerTranscriptTool(ctx) {
                         builder.fix(record);
                 }
             }
-            // Convergence "found nothing → settled" marker when the trend ends on 0.
+            // End state: an explicit stoppedReason wins; otherwise derive it from
+            // the trend. A run that settled closes as "converged"; a run that did
+            // real work but never trended to 0 closes as "max_rounds_reached";
+            // a capture with no rounds stays "active" (nothing recorded yet).
+            const explicitReason = typeof args.stoppedReason === 'string' && args.stoppedReason.trim()
+                ? args.stoppedReason.trim()
+                : '';
             const last = convergence[convergence.length - 1];
-            if (convergence.length > 0 && last === 0)
-                builder.finish();
+            if (explicitReason)
+                builder.finish(explicitReason);
+            else if (convergence.length > 0 && last === 0)
+                builder.finish('converged');
+            else if (roundsExecuted > 0)
+                builder.finish('max_rounds_reached');
             const persisted = await persistChecked(file, builder.serialize());
             if (!persisted.ok) {
                 return { operation: 'capture', found: true, updated: false, error: persisted.error };
@@ -346,7 +368,7 @@ function rehydrateBuilder(manifest, approval) {
             builder.decision(e);
     builder.setNudge(manifest.nudge?.text ?? null);
     if (!manifest.active)
-        builder.finish();
+        builder.finish(manifest.stoppedReason ?? undefined);
     return builder;
 }
 /** Atomically persist a manifest (unique temp + rename) under `.iterate/`. */

package/dist/tools/triage.js

@@ -1,5 +1,5 @@
-import { copyFileSync, existsSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
+import { copyFileSync, existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import yaml from 'js-yaml';
 import { resolveProjectRootForExec } from "../config-loader.js";
@@ -10,6 +10,8 @@ const PERSONALIZATION_KEY = 'personalization';
 const KNOWN_INTENTIONAL_KEY = 'known_intentional';
 /** Max entries per single `apply` call. */
 const MAX_ENTRIES = 500;
+/** How many timestamped config backups are retained (older ones are removed). */
+export const MAX_TRIAGE_BACKUPS = 5;
 /** Whole-file marker line (matches review.ts filterKnownIntentional semantics). */
 const WHOLE_FILE_LINE = 0;
 // ─── Pure helpers (exported for unit tests) ─────────────────────────────────
@@ -148,6 +150,33 @@ export function readKnownIntentional(config) {
 export function backupSuffix(now = new Date()) {
     return now.toISOString().replace(/[:.]/g, '-');
 }
+/**
+ * Bound the timestamped config backups: after a fresh one is written, delete
+ * every older `config.bak-*` file beyond the newest `keep`. Best-effort — a
+ * filesystem failure here must never fail the apply that just succeeded
+ * (backups are a safety net, not a requirement).
+ * @returns the absolute paths of the backups that were removed.
+ */
+export function pruneOldConfigBackups(configPath, keep = MAX_TRIAGE_BACKUPS) {
+    const removed = [];
+    try {
+        const dir = dirname(configPath);
+        const prefix = `${basename(configPath)}.bak-`;
+        const matches = readdirSync(dir)
+            .filter((f) => f.startsWith(prefix))
+            .sort();
+        // Keep the newest `keep`; remove everything older.
+        const doomed = matches.slice(0, Math.max(0, matches.length - keep));
+        for (const f of doomed) {
+            rmSync(join(dir, f), { force: true });
+            removed.push(join(dir, f));
+        }
+    }
+    catch {
+        // Best-effort cleanup — never surface a cleanup failure.
+    }
+    return removed;
+}
 // ─── File I/O ───────────────────────────────────────────────────────────────
 /** Load the raw config object (empty when the file is missing). */
 function readConfigFile(configPath) {
@@ -213,6 +242,10 @@ function applyEntries(projectRoot, incoming) {
             error: `Failed to write config: ${String(err)}${rollbackError}`,
         };
     }
+    // Success: bound the accumulation of timestamped backups so a long-lived
+    // project never collects an unbounded pile of config snapshots.
+    if (backupPath)
+        pruneOldConfigBackups(configPath);
     return { ok: true, added, skipped, count: merged.length, configPath, backupPath };
 }
 /**

package/dist/transcript.js

@@ -107,6 +107,7 @@ export class ReviewTranscriptBuilder {
     round = 0;
     maxRounds = 0;
     active = true;
+    stoppedReason = null;
     rounds = [];
     convergence = [];
     globalFindings = [];
@@ -158,9 +159,15 @@ export class ReviewTranscriptBuilder {
             this.phases.push(n);
         this.touch();
     }
-    /** End the run (stops the "active" pulsing in the UI). */
-    finish() {
+    /**
+     * End the run (stops the "active" pulsing in the UI). `reason` records WHY
+     * it ended, so a run stopped by max-rounds or validation is never mistaken
+     * for a live run NOR for a clean convergence.
+     */
+    finish(reason) {
         this.active = false;
+        if (typeof reason === 'string' && reason.trim())
+            this.stoppedReason = reason.trim();
         this.touch();
     }
     /** Open a review round, capturing the current round index. */
@@ -385,6 +392,7 @@ export class ReviewTranscriptBuilder {
             checkpoint: this.checkpoint,
             timeline: this.timeline,
             nudge: this.nudge,
+            stoppedReason: this.stoppedReason,
             approval: {
                 active: this.approval !== 'allow',
                 policy: this.approval,

package/lib/client.js

@@ -941,18 +941,25 @@ function computeConvergenceProgress(report) {
     report.convergence ?? {}
   );
   const totalRounds = typeof convergence.totalRounds === "number" ? convergence.totalRounds : 1;
-  const currentRounds = (
-    /** @type {Array<unknown>} */
-    (report.rounds ?? []).length
-  );
+  const currentRounds = currentRoundNumber(report);
   if (!(totalRounds > 0)) return 0;
   return Math.min(100, Math.round(currentRounds / totalRounds * 100));
 }
-function getCurrentRound(report) {
-  return (
-    /** @type {Array<unknown>} */
-    (report.rounds ?? []).length
+function currentRoundNumber(report) {
+  const rounds = (
+    /** @type {Array<Record<string, unknown>>} */
+    report.rounds ?? []
   );
+  let max = 0;
+  for (const r of rounds) {
+    if (!r || typeof r !== "object") continue;
+    const n = Number(r.round);
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  return rounds.length > 0 && max === 0 ? rounds.length : max;
+}
+function getCurrentRound(report) {
+  return currentRoundNumber(report);
 }
 function getTotalRounds(report) {
   const convergence = (
@@ -1713,6 +1720,25 @@ function severityColor(severity) {
 function severityLabel(severity) {
   return SEVERITY_LABEL[coerceSeverity(severity)];
 }
+function stoppedReasonLabel(reason) {
+  switch (reason) {
+    case "converged":
+      return "\u5DF2\u7ED3\u675F \xB7 \u5DF2\u6536\u655B\uFF08\u65E0\u65B0\u53D1\u73B0\uFF09";
+    case "max_rounds_reached":
+      return "\u5DF2\u7ED3\u675F \xB7 \u8FBE\u5230\u8F6E\u6570\u4E0A\u9650";
+    case "aborted_by_validation":
+      return "\u5DF2\u7ED3\u675F \xB7 \u9A8C\u8BC1\u5931\u8D25\u540E\u56DE\u6EDA\u505C\u6B62";
+    case "aborted_by_config":
+      return "\u5DF2\u7ED3\u675F \xB7 \u9A8C\u8BC1\u547D\u4EE4\u4E0D\u5728\u767D\u540D\u5355\uFF08\u914D\u7F6E\u9700\u4FEE\u590D\uFF09";
+    default:
+      return reason ? `\u5DF2\u7ED3\u675F \xB7 ${reason}` : "\u5DF2\u7ED3\u675F";
+  }
+}
+function runStatusText(live, manifest) {
+  if (live) return "\u8FD0\u884C\u4E2D";
+  const reason = manifest && typeof manifest.stoppedReason === "string" ? manifest.stoppedReason : "";
+  return reason ? stoppedReasonLabel(reason) : "\u5DF2\u7ED3\u675F";
+}
 function readSlots(ctx) {
   if (ctx && ctx.slots && typeof ctx.slots.inject === "function" && typeof ctx.slots.register === "function") {
     return ctx.slots;
@@ -1858,7 +1884,7 @@ function ConvergenceDashboard(props) {
     key: "phase",
     "data-live": transcript.active === true ? "" : void 0,
     title: transcript.active === true ? `\u5F53\u524D\u5904\u4E8E\u300C${phase}\u300D\u9636\u6BB5\uFF08\u8FD0\u884C\u4E2D\uFF09` : `\u6700\u8FD1\u4E00\u6B21\u6267\u884C\u505C\u7559\u5728\u300C${phase}\u300D\u9636\u6BB5\uFF08\u5DF2\u7ED3\u675F\uFF09`
-  }, `${phase} \xB7 ${transcript.active === true ? "\u8FD0\u884C\u4E2D" : "\u5DF2\u7ED3\u675F"}`) : null;
+  }, `${phase} \xB7 ${runStatusText(transcript.active === true, transcript)}`) : null;
   const taskModeTranscript = latestTranscript(session);
   const taskMode = taskModeTranscript?.taskMode;
   const taskModeChip = taskMode ? React.createElement("span", {
@@ -3171,7 +3197,7 @@ ${JSON.stringify({ operation: "nudge", text: null }, null, 2)}
         "div",
         { className: "iterate-obs-block-head" },
         React.createElement("span", {}, "\u8FD0\u884C\u63A7\u5236\u53F0"),
-        React.createElement("span", { className: "iterate-obs-badge", "data-live": live ? "" : void 0 }, live ? "\u8FD0\u884C\u4E2D" : "\u5DF2\u7ED3\u675F"),
+        React.createElement("span", { className: "iterate-obs-badge", "data-live": live ? "" : void 0 }, runStatusText(live, manifest)),
         React.createElement("span", { className: "iterate-obs-head-meta" }, `\u6279\u51C6\u7B56\u7565\uFF1A${policyLabel}`)
       ),
       React.createElement(
@@ -3767,7 +3793,7 @@ ${JSON.stringify({ operation: "clear" }, null, 2)}
       "div",
       { className: "iterate-obs-head", "data-closed": open ? void 0 : "", onClick: () => setOpen((v) => !v) },
       React.createElement("span", { className: "iterate-obs-title" }, "iterate \u89C2\u6D4B\u53F0"),
-      React.createElement("span", { className: "iterate-obs-badge", "data-live": live ? "" : void 0 }, live ? "\u8FD0\u884C\u4E2D" : "\u5DF2\u7ED3\u675F"),
+      React.createElement("span", { className: "iterate-obs-badge", "data-live": live ? "" : void 0 }, runStatusText(live, manifest)),
       React.createElement("span", { className: "iterate-obs-head-meta" }, headMeta || "runtime"),
       React.createElement("button", {
         className: "iterate-btn",

package/lib/parse.js

@@ -1217,12 +1217,34 @@ export function computeConvergenceProgress(report) {
   const totalRounds = typeof convergence.totalRounds === 'number'
     ? convergence.totalRounds
     : 1
-  const currentRounds = /** @type {Array<unknown>} */ (report.rounds ?? []).length
+  const currentRounds = currentRoundNumber(report)
   // Guard against an empty report (totalRounds <= 0) producing NaN.
   if (!(totalRounds > 0)) return 0
   return Math.min(100, Math.round((currentRounds / totalRounds) * 100))
 }
 
+/**
+ * The actual current round (1-indexed) carried by a report. Uses the highest
+ * per-round `round` field: a normal-mode aggregate ships ONLY the live round
+ * (`rounds: [{round: r, ...}]`), so `rounds.length` would be stuck at 1 while
+ * the run is on round 3. Dry-run aggregates ship the cumulative list, where
+ * the round numbers and the array length agree anyway.
+ *
+ * @param {Record<string, unknown>} report
+ * @returns {number}
+ */
+function currentRoundNumber(report) {
+  const rounds = /** @type {Array<Record<string, unknown>>} */ (report.rounds ?? [])
+  let max = 0
+  for (const r of rounds) {
+    if (!r || typeof r !== 'object') continue
+    const n = Number(r.round)
+    if (Number.isFinite(n) && n > max) max = n
+  }
+  // Fallback: no usable round numbers → array length (covers all-0 rounds).
+  return rounds.length > 0 && max === 0 ? rounds.length : max
+}
+
 /**
  * Get the current round number (1-indexed) from a report.
  *
@@ -1230,7 +1252,7 @@ export function computeConvergenceProgress(report) {
  * @returns {number}
  */
 export function getCurrentRound(report) {
-  return (/** @type {Array<unknown>} */ (report.rounds ?? [])).length
+  return currentRoundNumber(report)
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-plugin",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "dsh plugin that turns the iterate skill into an autonomous closed-loop harness with quality command center and experience bank (v3.3). Features: plan -> parallel review xN -> atomic fixes -> validate -> loop -> auto-stop, plus dry-run pure-review mode, quality gate compute/persist, writable experience bank, defense events stream (record + bilingual labels), and native command buttons — with a live quality command center (F8/F9/F10 render real session data), §8 assign-fix instruction, and task_mode indicator wired end to end.",
   "type": "module",
   "license": "MIT",
@@ -37,7 +37,8 @@
         "0.1.5-alpha.1": "compatible",
         "0.1.5-alpha.2": "compatible",
         "0.1.5-rc.1": "compatible",
-        "0.1.5-rc.2": "compatible"
+        "0.1.5-rc.2": "compatible",
+        "0.1.6-alpha.1": "compatible"
       }
     },
     "client": {
@@ -75,13 +76,14 @@
   },
   "dependencies": {
     "@deepseek-ai/cordis": "4.0.2",
-    "@deepseek-ai/dsh-tools": "0.1.5-rc.2",
-    "@deepseek-ai/dsh-util-values": "0.1.5-rc.2",
-    "js-yaml": "4.3.1"
+    "@deepseek-ai/dsh-tools": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-util-values": "0.1.6-alpha.1",
+    "js-yaml": "4.3.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-jobs": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-agent": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-jobs": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "0.1.6-alpha.1",
     "@types/js-yaml": "4.0.9",
     "@types/node": "22.15.0",
     "@types/react": "19.2.2",