iterate-plugin 3.5.4 → 3.5.6

package/dist/tools/transcript.js

@@ -148,7 +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).' },
+            stoppedReason: { type: 'string', description: 'For `capture`: why the run ended — "converged" | "max_rounds_reached" | "aborted_by_validation" | "aborted_by_config" | "schema_invalid" | "no_usable_reviewer_output" | "inconclusive". 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).' },
         },
@@ -344,13 +344,24 @@ function rehydrateBuilder(manifest, approval) {
         maxRounds: manifest.maxRounds,
     });
     for (const r of Array.isArray(manifest.rounds) ? manifest.rounds : []) {
+        // A malformed/null round row must be skipped, never a throw (the caller
+        // wraps rehydrate in a fallback, but preserving sibling rows is better).
+        if (!r || typeof r !== 'object')
+            continue;
         builder.roundStart(r.round, manifest.maxRounds);
         for (const t of Array.isArray(r.threads) ? r.threads : []) {
-            builder.reviewerStart(t.dimension || 'review', t.attempt || 1);
-            builder.reviewerMessage((t.messages ?? []).join('\n'));
-            builder.reviewerRead(t.readFiles ?? []);
-            for (const f of t.findings ?? [])
-                builder.reviewerFindings([f]);
+            // restoreThread (not reviewerStart + reviewerMessage(join)) preserves the
+            // message ARRAY boundaries and the thread's own dimension: rehydration
+            // previously collapsed each thread's messages into one string and, once a
+            // round hit the per-round thread cap, silently DROPPED the extra threads
+            // / mis-merged their findings into the previous dimension's thread.
+            builder.restoreThread(r.round, {
+                dimension: t.dimension,
+                attempt: t.attempt,
+                messages: t.messages,
+                readFiles: t.readFiles,
+                findings: t.findings,
+            });
         }
     }
     for (let idx = 0; idx < (manifest.convergence ?? []).length; idx += 1) {

package/dist/tools/triage.js

@@ -184,8 +184,9 @@ function readConfigFile(configPath) {
         return {};
     const content = readFileSync(configPath, 'utf-8');
     const parsed = yaml.load(content);
-    if (!parsed || typeof parsed !== 'object') {
-        // A config that exists but is not a YAML mapping must NOT be silently
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        // A config that exists but is NOT a YAML mapping (including a YAML list,
+        // which `typeof [] === 'object'` alone would accept) must NOT be silently
         // treated as empty: writing over it would destroy user data. Callers
         // surface this as an error and refuse to write.
         throw new Error('existing iterate.config.yaml is not a valid YAML mapping');

package/dist/transcript.js

@@ -54,6 +54,20 @@ function clampStringList(source, cap) {
     }
     return out;
 }
+/**
+ * Deep-clone a decision-timeline payload so it is decoupled from the caller's
+ * live object. structuredClone is available in every supported Node release;
+ * on the off chance it is missing, fall back to a JSON round-trip (decision
+ * payloads are JSON-serializable by construction).
+ */
+function cloneDecisionData(data) {
+    try {
+        return structuredClone(data);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(data));
+    }
+}
 /** Normalize a single finding, dropping malformed entries. */
 function normalizeFinding(input) {
     if (!input || typeof input !== 'object')
@@ -68,7 +82,9 @@ function normalizeFinding(input) {
     const severity = sev === 'critical' || sev === 'high' || sev === 'medium' || sev === 'low'
         ? sev
         : 'low';
-    const line = typeof f.line === 'number' && Number.isFinite(f.line) ? f.line : 0;
+    // Only a non-negative integer is a real line anchor; a fractional/malformed
+    // value (e.g. 3.7 from a bypassed schema) must not leak into the manifest.
+    const line = typeof f.line === 'number' && Number.isInteger(f.line) && f.line >= 0 ? f.line : 0;
     return {
         dimension,
         file,
@@ -81,12 +97,23 @@ function normalizeFinding(input) {
         acknowledged: typeof f.acknowledged === 'boolean' ? f.acknowledged : undefined,
     };
 }
+/**
+ * Append one raw finding to a thread's list, bound to MAX_FINDINGS_PER_THREAD
+ * with NEWEST-WINS eviction (drop the oldest findings once the cap is hit).
+ * A single oversized fixer agent could otherwise OOM the client with an
+ * unbounded finding dump inside one thread.
+ */
+function pushThreadFinding(thread, raw) {
+    thread.findings.push(raw);
+    if (thread.findings.length > MAX_FINDINGS_PER_THREAD) {
+        thread.findings.splice(0, thread.findings.length - MAX_FINDINGS_PER_THREAD);
+    }
+}
 /** Merge a report snapshot's findings/readFiles into a thread by dimension. */
 function mergeReportIntoThread(thread, findings, readFiles) {
     for (const raw of findings) {
-        const f = normalizeFinding(raw);
-        if (f)
-            thread.findings.push(raw);
+        if (normalizeFinding(raw))
+            pushThreadFinding(thread, raw);
     }
     for (const r of readFiles ?? []) {
         if (typeof r === 'string')
@@ -111,6 +138,7 @@ export class ReviewTranscriptBuilder {
     rounds = [];
     convergence = [];
     globalFindings = [];
+    globalSeenKeys = new Set();
     fixes = [];
     checkpoint = null;
     timeline = [];
@@ -193,7 +221,9 @@ export class ReviewTranscriptBuilder {
         const att = typeof attempt === 'number' && Number.isFinite(attempt) ? Math.floor(attempt) : 1;
         this.roundStart(this.round);
         const live = this.rounds[this.round - 1];
-        if (live && this.threadCount(live) < MAX_THREADS_PER_ROUND) {
+        if (!live)
+            return;
+        if (this.threadCount(live) < MAX_THREADS_PER_ROUND) {
             live.threads.push({
                 dimension: dim || 'review',
                 attempt: att > 0 ? att : 1,
@@ -202,6 +232,78 @@ export class ReviewTranscriptBuilder {
                 findings: [],
             });
         }
+        else {
+            // Thread cap reached: route the extra dimension/retry into ONE shared
+            // "other" overflow thread instead of silently dropping it. A dropped
+            // reviewerStart used to leave `currentThread()` pointing at the PREVIOUS
+            // dimension's thread, so its findings were mis-attributed to that
+            // dimension. The overflow thread stays bounded (at most ONE extra thread
+            // per round) while keeping over-cap findings attributable to "other".
+            let overflow = live.threads.find((t) => t.dimension === 'other');
+            if (!overflow) {
+                overflow = {
+                    dimension: 'other',
+                    attempt: att > 0 ? att : 1,
+                    messages: [],
+                    readFiles: [],
+                    findings: [],
+                };
+                live.threads.push(overflow);
+            }
+        }
+        this.touch();
+    }
+    /**
+     * Restore ONE persisted thread during rehydration, preserving the message
+     * ARRAY boundaries (a rehydrated manifest is re-serialized on the next nudge
+     * edit, so collapsed messages would silently rewrite the evidence) and the
+     * thread's own dimension (never merging it into a previous dimension's
+     * thread). Bypasses the live per-round cap — the manifest already enforced
+     * it at capture time — but every restored field is hard-bounded so a hostile
+     * hand-edited manifest can never blow up memory.
+     */
+    restoreThread(round, thread) {
+        const r = typeof round === 'number' && Number.isFinite(round)
+            ? Math.min(Math.floor(round), MAX_ROUNDS)
+            : 1;
+        this.roundStart(r);
+        const live = this.rounds[this.round - 1];
+        if (!live)
+            return;
+        if (!thread || typeof thread !== 'object')
+            return;
+        // Hostile-manifest guard: keep the live hard bound (with headroom for the
+        // single overflow thread) and newest-first truncate beyond it.
+        if (live.threads.length >= MAX_THREADS_PER_ROUND * 2 + 1)
+            return;
+        const dim = typeof thread.dimension === 'string' && thread.dimension.trim()
+            ? thread.dimension.trim()
+            : 'review';
+        const att = typeof thread.attempt === 'number' && Number.isFinite(thread.attempt)
+            ? Math.floor(thread.attempt)
+            : 1;
+        const t = {
+            dimension: dim,
+            attempt: att > 0 ? att : 1,
+            messages: [],
+            readFiles: [],
+            findings: [],
+        };
+        const messages = Array.isArray(thread.messages) ? thread.messages : [];
+        for (const m of messages.slice(0, MAX_MESSAGES_PER_THREAD)) {
+            if (typeof m === 'string' && m.trim())
+                t.messages.push(m);
+        }
+        if (Array.isArray(thread.readFiles)) {
+            t.readFiles.push(...dedupePaths(thread.readFiles));
+        }
+        if (Array.isArray(thread.findings)) {
+            for (const f of thread.findings) {
+                if (normalizeFinding(f))
+                    pushThreadFinding(t, f);
+            }
+        }
+        live.threads.push(t);
         this.touch();
     }
     /** Append narration (assistant text) to the current reviewer thread. */
@@ -237,12 +339,11 @@ export class ReviewTranscriptBuilder {
             for (const raw of findings) {
                 const f = normalizeFinding(raw);
                 if (f) {
-                    thread.findings.push(raw);
-                    this.globalFindings.push(f);
+                    pushThreadFinding(thread, raw);
+                    this.addGlobal(f);
                 }
             }
         }
-        this.reevaluateGlobal();
         this.touch();
     }
     /** Merge a round-level report snapshot (findings + readFiles) into a thread. */
@@ -255,9 +356,8 @@ export class ReviewTranscriptBuilder {
         for (const raw of findings) {
             const f = normalizeFinding(raw);
             if (f)
-                this.globalFindings.push(f);
+                this.addGlobal(f);
         }
-        this.reevaluateGlobal();
         this.touch();
     }
     // ─── Convergence (F2) ───────────────────────────────────────────────────
@@ -337,8 +437,12 @@ export class ReviewTranscriptBuilder {
                 ? Math.floor(entry.round)
                 : this.round,
             type,
-            data: entry.data && typeof entry.data === 'object'
-                ? entry.data
+            data: entry.data && typeof entry.data === 'object' && !Array.isArray(entry.data)
+                // Deep clone so a caller mutating its own object later can never
+                // alias into the timeline (serialize would then emit the mutated
+                // values instead of what was actually decided). Decision-log payloads
+                // are small JSON, so the clone cost is negligible.
+                ? cloneDecisionData(entry.data)
                 : {},
         });
         if (this.timeline.length > MAX_TIMELINE) {
@@ -385,9 +489,9 @@ export class ReviewTranscriptBuilder {
             maxRounds: this.maxRounds,
             rounds,
             convergence: this.convergence,
-            findings: this.globalFindings.length > MAX_FINDINGS_TOTAL
-                ? this.globalFindings.slice(0, MAX_FINDINGS_TOTAL)
-                : this.globalFindings,
+            // addGlobal maintains the newest-wins cap incrementally, so the array is
+            // already ≤ MAX_FINDINGS_TOTAL — no post-hoc slice needed.
+            findings: this.globalFindings,
             fixes: this.fixes,
             checkpoint: this.checkpoint,
             timeline: this.timeline,
@@ -416,25 +520,23 @@ export class ReviewTranscriptBuilder {
     threadCount(live) {
         return live.threads.length;
     }
-    /** Recompute the global finding list from per-thread findings (dedup). */
-    reevaluateGlobal() {
-        // Rebuild from threads to derive a deterministic global list.
-        this.globalFindings.length = 0;
-        const seen = new Set();
-        for (const r of this.rounds) {
-            for (const t of r.threads) {
-                for (const raw of t.findings) {
-                    const f = normalizeFinding(raw);
-                    if (!f)
-                        continue;
-                    const key = `${f.file}\u0000${f.line ?? 0}\u0000${f.dimension}\u0000${f.summary}`;
-                    if (seen.has(key))
-                        continue;
-                    seen.add(key);
-                    this.globalFindings.push(f);
-                    if (this.globalFindings.length >= MAX_FINDINGS_TOTAL)
-                        return;
-                }
+    /**
+     * Insert one deduplicated finding into the compact global list.
+     * NEWEST-WINS: when the global cap (MAX_FINDINGS_TOTAL) is hit, the oldest
+     * kept finding is evicted so fresh, still-relevant findings survive — this
+     * is the documented contract. Amortized O(1): dedupe via a seen-key set and
+     * eviction is one `shift` per overflow insert.
+     */
+    addGlobal(f) {
+        const key = `${f.file}\u0000${f.line ?? 0}\u0000${f.dimension}\u0000${f.summary}`;
+        if (this.globalSeenKeys.has(key))
+            return;
+        this.globalSeenKeys.add(key);
+        this.globalFindings.push(f);
+        if (this.globalFindings.length > MAX_FINDINGS_TOTAL) {
+            const evicted = this.globalFindings.shift();
+            if (evicted) {
+                this.globalSeenKeys.delete(`${evicted.file}\u0000${evicted.line ?? 0}\u0000${evicted.dimension}\u0000${evicted.summary}`);
             }
         }
     }

package/lib/client.js

@@ -465,6 +465,10 @@ function normalizeTranscript(manifest) {
     phases: asArray(safeGet(src, "phases")).map((p) => typeof p === "string" ? p : ""),
     round: asNum(safeGet(src, "round")),
     maxRounds: asNum(safeGet(src, "maxRounds")),
+    // v3.5: why a FINISHED run stopped (converged / max_rounds_reached /
+    // aborted_by_validation / aborted_by_config). Required for the
+    // observatory badge to render the stop reason instead of a bare "已结束".
+    stoppedReason: src.stoppedReason === null || src.stoppedReason === void 0 ? null : asStr(safeGet(src, "stoppedReason")) || null,
     rounds,
     convergence: asArray(safeGet(src, "convergence")).map((n) => asCount(n)),
     findings: asArray(safeGet(src, "findings")).map((f) => ({ ...f })),
@@ -1207,6 +1211,26 @@ function trendMax(points) {
   }
   return max;
 }
+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";
+    case "inconclusive":
+      return "\u5DF2\u7ED3\u675F \xB7 \u8F6E\u6B21\u7ED3\u8BBA\u4E0D\u660E\uFF08\u5BA1\u67E5\u8F93\u51FA\u65E0\u6548\uFF09";
+    case "schema_invalid":
+      return "\u5DF2\u7ED3\u675F \xB7 \u5BA1\u67E5\u8F93\u51FA\u8FDE\u7EED schema \u6821\u9A8C\u5931\u8D25";
+    case "no_usable_reviewer_output":
+      return "\u5DF2\u7ED3\u675F \xB7 \u65E0\u53EF\u7528\u5BA1\u67E5\u8F93\u51FA";
+    default:
+      return reason ? `\u5DF2\u7ED3\u675F \xB7 ${reason}` : "\u5DF2\u7ED3\u675F";
+  }
+}
 function buildCompletionSummary(report) {
   const conv = (
     /** @type {Record<string, unknown>} */
@@ -1225,6 +1249,7 @@ var CONFIG_EDIT_FIELDS = [
   { key: "dimensions", label: "\u5BA1\u67E5\u7EF4\u5EA6", hint: '\u6570\u7EC4\uFF0C\u5982 ["correctness","security"]' },
   { key: "max_rounds", label: "\u6700\u5927\u8F6E\u6570", hint: "\u6B63\u6574\u6570" },
   { key: "review.scope", label: "\u5BA1\u67E5\u8303\u56F4", hint: '"full" \u6216 "changed-only"' },
+  { key: "reasoning_effort", label: "\u5BA1\u67E5\u63A8\u7406\u5F3A\u5EA6", hint: '"low" / "medium" / "high"\uFF0C\u7F3A\u7701\u8DDF\u968F\u6A21\u578B\u9ED8\u8BA4' },
   { key: "atomic.max_lines", label: "\u539F\u5B50\u4FEE\u590D\u4E0A\u9650\u884C\u6570", hint: "\u6B63\u6574\u6570" },
   { key: "git.push_per_round", label: "\u6BCF\u8F6E\u63A8\u9001", hint: "true / false" }
 ];
@@ -1720,20 +1745,6 @@ 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 : "";
@@ -1763,6 +1774,7 @@ var slotsSvc = void 0;
 var themeSvc = void 0;
 var storage = null;
 var themeDisposer = null;
+var themeListener = null;
 var themeEnabled = true;
 var roundPulseListeners = [];
 function emitRoundPulse(round, converged) {
@@ -1784,6 +1796,31 @@ function clearThemeSkin() {
     themeDisposer = null;
   }
 }
+function registerThemeListener(ctx) {
+  if (typeof ctx.on !== "function") return;
+  if (themeListener) {
+    try {
+      themeListener();
+    } catch {
+    }
+    themeListener = null;
+  }
+  const off = ctx.on("theme/change", () => {
+    if (themeEnabled) applyThemeSkin();
+  });
+  themeListener = typeof off === "function" ? off : null;
+  if (typeof ctx.effect === "function") {
+    ctx.effect(() => {
+      if (themeListener) {
+        try {
+          themeListener();
+        } catch {
+        }
+        themeListener = null;
+      }
+    });
+  }
+}
 function setThemeEnabled(enabled) {
   themeEnabled = enabled;
   if (storage) storage.set(THEME_STORAGE_KEY, enabled ? "1" : "0");
@@ -3870,18 +3907,21 @@ function apply(ctx) {
   themeEnabled = savedTheme === null ? true : savedTheme === "1";
   if (themeEnabled) applyThemeSkin();
   if (typeof document !== "undefined" && document.createElement && document.head) {
-    const style = document.createElement("style");
-    style.dataset.plugin = PLUGIN_TAG;
-    style.dataset.pluginCss = "iterate-main";
-    style.textContent = ITERATE_CSS;
-    document.head.appendChild(style);
-    if (typeof ctx.effect === "function") {
-      ctx.effect(() => {
-        try {
-          style.remove();
-        } catch {
-        }
-      });
+    if (!document.head.querySelector('style[data-iterate-lock="1"]')) {
+      const style = document.createElement("style");
+      style.dataset.iterateLock = "1";
+      style.dataset.plugin = PLUGIN_TAG;
+      style.dataset.pluginCss = "iterate-main";
+      style.textContent = ITERATE_CSS;
+      document.head.appendChild(style);
+      if (typeof ctx.effect === "function") {
+        ctx.effect(() => {
+          try {
+            style.remove();
+          } catch {
+          }
+        });
+      }
     }
   }
   if (slotsSvc === void 0) {
@@ -3925,11 +3965,7 @@ function apply(ctx) {
       )
     );
   }
-  if (typeof ctx.on === "function") {
-    ctx.on("theme/change", () => {
-      if (themeEnabled) applyThemeSkin();
-    });
-  }
+  registerThemeListener(ctx);
 }
 return module.exports; } });
 

package/lib/parse.js

@@ -581,6 +581,12 @@ export function normalizeTranscript(manifest) {
     phases: asArray(safeGet(src, 'phases')).map((p) => (typeof p === 'string' ? p : '')),
     round: asNum(safeGet(src, 'round')),
     maxRounds: asNum(safeGet(src, 'maxRounds')),
+    // v3.5: why a FINISHED run stopped (converged / max_rounds_reached /
+    // aborted_by_validation / aborted_by_config). Required for the
+    // observatory badge to render the stop reason instead of a bare "已结束".
+    stoppedReason: src.stoppedReason === null || src.stoppedReason === undefined
+      ? null
+      : asStr(safeGet(src, 'stoppedReason')) || null,
     rounds,
     convergence: asArray(safeGet(src, 'convergence')).map((n) => asCount(n)),
     findings: asArray(safeGet(src, 'findings')).map((f) => ({ ...f })),
@@ -1681,6 +1687,33 @@ export function trendMax(points) {
   return max
 }
 
+// ─── Stop reason badges (v3.5.5) ─────────────────────────────────────────────
+//
+// Every value the iterate loop can report as `stoppedReason` — including the
+// schema-retry batch (schema_invalid / no_usable_reviewer_output / inconclusive)
+// — maps to a concrete Chinese label. Unknown values still get a readable
+// default instead of a bare "已结束". Kept in parse.js so both the client
+// observatory badge and Node unit tests share one source of truth.
+
+/**
+ * Chinese badge label for a run's `stoppedReason`, or null/undefined-safe.
+ *
+ * @param {string | null | undefined} reason
+ * @returns {string}
+ */
+export function stoppedReasonLabel(reason) {
+  switch (reason) {
+    case 'converged': return '已结束 · 已收敛（无新发现）'
+    case 'max_rounds_reached': return '已结束 · 达到轮数上限'
+    case 'aborted_by_validation': return '已结束 · 验证失败后回滚停止'
+    case 'aborted_by_config': return '已结束 · 验证命令不在白名单（配置需修复）'
+    case 'inconclusive': return '已结束 · 轮次结论不明（审查输出无效）'
+    case 'schema_invalid': return '已结束 · 审查输出连续 schema 校验失败'
+    case 'no_usable_reviewer_output': return '已结束 · 无可用审查输出'
+    default: return reason ? `已结束 · ${reason}` : '已结束'
+  }
+}
+
 // ─── Completion notification ────────────────────────────────────────────────
 
 /**
@@ -1711,6 +1744,7 @@ export const CONFIG_EDIT_FIELDS = [
   { key: 'dimensions', label: '审查维度', hint: '数组，如 ["correctness","security"]' },
   { key: 'max_rounds', label: '最大轮数', hint: '正整数' },
   { key: 'review.scope', label: '审查范围', hint: '"full" 或 "changed-only"' },
+  { key: 'reasoning_effort', label: '审查推理强度', hint: '"low" / "medium" / "high"，缺省跟随模型默认' },
   { key: 'atomic.max_lines', label: '原子修复上限行数', hint: '正整数' },
   { key: 'git.push_per_round', label: '每轮推送', hint: 'true / false' },
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-plugin",
-  "version": "3.5.4",
+  "version": "3.5.6",
   "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",
@@ -38,7 +38,11 @@
         "0.1.5-alpha.2": "compatible",
         "0.1.5-rc.1": "compatible",
         "0.1.5-rc.2": "compatible",
-        "0.1.6-alpha.1": "compatible"
+        "0.1.6-alpha.1": "compatible",
+        "0.1.6-alpha.2": "compatible",
+        "0.1.7-alpha.1": "compatible",
+        "0.1.7-alpha.2": "compatible",
+        "0.1.7-rc.1": "compatible"
       }
     },
     "client": {
@@ -75,15 +79,15 @@
     "test:validate": "tsx --test test/validate.test.ts"
   },
   "dependencies": {
-    "@deepseek-ai/cordis": "4.0.2",
-    "@deepseek-ai/dsh-tools": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-util-values": "0.1.6-alpha.1",
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-util-values": "0.1.7-rc.1",
     "js-yaml": "4.3.2"
   },
   "devDependencies": {
-    "@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",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-jobs": "0.1.7-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.1",
     "@types/js-yaml": "4.0.9",
     "@types/node": "22.15.0",
     "@types/react": "19.2.2",

package/src/atomic-fs.ts

@@ -54,11 +54,19 @@ function tempPathFor(filePath: string): string {
  */
 export function writeTextAtomic(filePath: string, data: string): void {
   const tmp = tempPathFor(filePath)
-  writeFileSync(tmp, data, 'utf-8')
+  try {
+    writeFileSync(tmp, data, 'utf-8')
+  } catch (err) {
+    // The write itself failed (disk full, permission, …): the temp file may
+    // already be partially written, so remove it before propagating — a
+    // failed write must never litter the directory either.
+    cleanupTemp(tmp)
+    throw err
+  }
   try {
     renameSync(tmp, filePath)
   } catch (err) {
-    // Best-effort temp cleanup so a failed write never litters the directory.
+    // Best-effort temp cleanup so a failed rename never litters the directory.
     cleanupTemp(tmp)
     throw err
   }
@@ -67,11 +75,19 @@ export function writeTextAtomic(filePath: string, data: string): void {
 /** Async variant of {@link writeTextAtomic} (same temp naming convention). */
 export async function writeTextAtomicAsync(filePath: string, data: string): Promise<void> {
   const tmp = tempPathFor(filePath)
-  await writeFile(tmp, data, 'utf-8')
+  try {
+    await writeFile(tmp, data, 'utf-8')
+  } catch (err) {
+    // The write itself failed (disk full, permission, …): the temp file may
+    // already be partially written, so remove it before propagating — a
+    // failed write must never litter the directory either.
+    await cleanupTempAsync(tmp)
+    throw err
+  }
   try {
     await rename(tmp, filePath)
   } catch (err) {
-    // Best-effort temp cleanup so a failed write never litters the directory.
+    // Best-effort temp cleanup so a failed rename never litters the directory.
     await cleanupTempAsync(tmp)
     throw err
   }