iterate-plugin 3.5.4 → 3.5.5

package/dist/tools/fix.js

@@ -364,6 +364,7 @@ export function registerFixTool(ctx) {
                     linesRemoved: { type: 'integer' },
                     diffSummary: { type: 'string' },
                     backupPath: { type: 'string' },
+                    warning: { type: 'string' },
                     error: { type: 'string' },
                 },
             },
@@ -451,6 +452,16 @@ export function registerFixTool(ctx) {
                 if (findFixRecord(registry, id)) {
                     return { ok: false, error: `finding already fixed this run (id: ${id})`, id };
                 }
+                // No-op guard: content-identical "fixes" (e.g. a fixer that re-sent the
+                // file unchanged) must never burn a backup, a write, or a registry/success
+                // record. Placed after the registry check so a re-sent fix of an id that
+                // was ALREADY fixed is still reported as "already fixed this run".
+                if (added === 0 && removed === 0) {
+                    return {
+                        ok: false,
+                        error: `no changes: the supplied content for ${file} is identical to the current content — apply a real edit`,
+                    };
+                }
                 const target = resolveProjectFile(projectRoot, file);
                 if (!target.ok)
                     return { ok: false, error: target.reason };
@@ -521,12 +532,15 @@ export function registerFixTool(ctx) {
                     }
                     return { ok: false, error: `failed to write fix registry: ${String(err)} (file restored from backup)` };
                 }
-                appendDecisionEntry(projectRoot, {
+                const logRes = appendDecisionEntry(projectRoot, {
                     timestamp,
                     round: args.round,
                     type: 'atomic_fix',
                     data: { id, file, finding: finding.summary, linesAdded: added, linesRemoved: removed },
                 });
+                // The fix itself succeeded, but a decision-log write failure would leave
+                // the audit trail incomplete — surface it (warning, not fatal) so the
+                // model/UI knows the record was not persisted.
                 return {
                     ok: true,
                     id,
@@ -536,6 +550,7 @@ export function registerFixTool(ctx) {
                     linesRemoved: removed,
                     diffSummary: record.diffSummary,
                     backupPath,
+                    ...(logRes.error ? { warning: logRes.error } : {}),
                 };
             });
             return result;
@@ -696,6 +711,7 @@ export function registerRollbackTool(ctx) {
                     ok: { type: 'boolean', required: true },
                     id: { type: 'string' },
                     file: { type: 'string' },
+                    warning: { type: 'string' },
                     error: { type: 'string' },
                 },
             },
@@ -736,7 +752,7 @@ export function registerRollbackTool(ctx) {
             catch (err) {
                 return { ok: false, error: `failed to update fix registry: ${String(err)}` };
             }
-            appendDecisionEntry(projectRoot, {
+            const logRes = appendDecisionEntry(projectRoot, {
                 timestamp: new Date().toISOString(),
                 round: record.round,
                 type: 'revert',
@@ -747,7 +763,12 @@ export function registerRollbackTool(ctx) {
             // a missing/corrupt transcript is left untouched and never breaks the
             // rollback flow.
             await markFixRolledBackInTranscript(projectRoot, id);
-            return { ok: true, id, file: record.finding.file };
+            return {
+                ok: true,
+                id,
+                file: record.finding.file,
+                ...(logRes.error ? { warning: logRes.error } : {}),
+            };
         },
     }));
 }

package/dist/tools/prune.js

@@ -28,7 +28,7 @@ import { join } from 'node:path';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { resolveProjectRootForExec } from "../config-loader.js";
 import { writeTextAtomic, writeJsonAtomic } from "../atomic-fs.js";
-import { readDecisionEntries, appendDecisionEntry } from "./decision-log.js";
+import { readDecisionEntries, appendDecisionEntry, acquireLogLock } from "./decision-log.js";
 import { readRegistry, recomputeRoundCounts } from "./fix.js";
 import { readExperienceBank, writeExperienceBank } from "./experience-store.js";
 import { readDefenseEvents, writeDefenseEvents } from "./defense-store.js";
@@ -234,26 +234,36 @@ export function inspectPrune(projectRoot, retainDays) {
  */
 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)}` };
+    // Take the cross-process log lock for the ENTIRE loop: with the mutex held,
+    // no concurrent appender can slip a fresh line into the read-before-rewrite
+    // window, so the first attempt is nearly always the only one. (The retry
+    // loop stays as defense-in-depth for the lock-unavailable path.)
+    const release = acquireLogLock(projectRoot);
+    try {
+        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 (cross-process, lock-unavailable path) 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` };
+    }
+    finally {
+        release();
     }
-    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`.
@@ -459,8 +469,10 @@ export function registerPruneTool(ctx) {
                 };
             }
             const result = executePrune(projectRoot, retainDays, report);
-            // Log the prune to the decision log.
-            appendDecisionEntry(projectRoot, {
+            // Log the prune to the decision log. The mutations already happened, so
+            // a failed log append is reported via `errors` — a silent audit miss
+            // (F2) must never pretend every deletion was recorded.
+            const logRes = appendDecisionEntry(projectRoot, {
                 timestamp: new Date().toISOString(),
                 round: 0,
                 type: 'decision',
@@ -475,6 +487,8 @@ export function registerPruneTool(ctx) {
                     deletedDefenseEvents: result.deletedDefenseEvents,
                 },
             });
+            if (logRes.error)
+                result.errors.push(logRes.error);
             return {
                 ok: true,
                 dryRun: false,

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')
@@ -81,12 +95,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 +136,7 @@ export class ReviewTranscriptBuilder {
     rounds = [];
     convergence = [];
     globalFindings = [];
+    globalSeenKeys = new Set();
     fixes = [];
     checkpoint = null;
     timeline = [];
@@ -237,12 +263,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 +280,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 +361,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 +413,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 +444,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 })),

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 })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-plugin",
-  "version": "3.5.4",
+  "version": "3.5.5",
   "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,8 @@
         "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"
       }
     },
     "client": {
@@ -76,14 +77,14 @@
   },
   "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/dsh-tools": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-util-values": "0.1.6-alpha.2",
     "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.6-alpha.2",
+    "@deepseek-ai/dsh-jobs": "^0.1.6-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.6-alpha.2",
     "@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
   }

package/src/config-loader.ts

@@ -12,7 +12,10 @@ export function loadConfig(projectRoot: string): IterateConfig | null {
   try {
     const content = readFileSync(join(projectRoot, 'iterate.config.yaml'), 'utf-8')
     const parsed = yaml.load(content) as Record<string, unknown>
-    if (!parsed || typeof parsed !== 'object') return null
+    // A YAML sequence root (e.g. a list of findings or a `- foo` file) must
+    // not masquerade as a config object — treating it as one would merge its
+    // indices into the config (config bomb). Reject it, not coerce it.
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
     return parsed as unknown as IterateConfig
   } catch {
     return null
@@ -158,7 +161,7 @@ export function flattenCommands(
  */
 export function validateConfig(config: unknown): string[] {
   const errors: string[] = []
-  if (!config || typeof config !== 'object') {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
     errors.push('root')
     return errors
   }
@@ -206,7 +209,9 @@ export type ProjectRootResult = { ok: true; root: string } | { ok: false; reason
  *      the DSH runtime injects per-session env into tool sub-processes).
  */
 export function resolveProjectRoot(input?: string, sessionCwd?: string): ProjectRootResult {
-  const raw = (input ?? '').trim()
+  // A non-string input (number, array, …) from a hostile tool invocation must
+  // be treated as "no explicit path" instead of crashing on `.trim()`.
+  const raw = (typeof input === 'string' ? input : '').trim()
   // A NUL byte can never name a real path and makes `resolve()` (and every
   // downstream fs call) throw — treat it as unsafe input, not a throw path.
   if (raw.includes('\0')) {

package/src/config-write.ts

@@ -10,8 +10,8 @@
  * config, always back up before writing, roll back on failure.
  */
 
-import { copyFileSync, existsSync, readFileSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
+import { copyFileSync, existsSync, readFileSync, readdirSync, rmSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
 import yaml from 'js-yaml'
 import { writeTextAtomic } from './atomic-fs.ts'
 
@@ -23,6 +23,46 @@ export function configBackupSuffix(now = new Date()): string {
   return now.toISOString().replace(/[:.]/g, '-')
 }
 
+/** Upper bound on configurable iteration rounds (config bomb guard). */
+export const MAX_MAX_ROUNDS = 100
+
+/** Upper bound on `atomic.max_lines` (a single fix never needs more). */
+export const MAX_ATOMIC_MAX_LINES = 10_000
+
+/** Upper bound on `atomic.max_adjacent_methods`. */
+export const MAX_MAX_ADJACENT_METHODS = 200
+
+/** Keep at most this many timestamped config backups (older ones are removed). */
+export const MAX_CONFIG_BACKUPS = 5
+
+/**
+ * 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 write that just succeeded.
+ * @returns the absolute paths of the backups that were removed.
+ */
+export function pruneOldConfigBackups(
+  configPath: string,
+  keep = MAX_CONFIG_BACKUPS,
+): string[] {
+  const removed: string[] = []
+  try {
+    const dir = dirname(configPath)
+    const prefix = `${basename(configPath)}.bak-`
+    const matches = existsSync(dir)
+      ? readdirSync(dir).filter((f) => f.startsWith(prefix)).sort()
+      : []
+    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
+}
+
 /**
  * Validate a partial config update.
  * Returns an array of error strings (empty when the update is valid).
@@ -45,8 +85,11 @@ export function validateConfigUpdates(updates: Record<string, unknown>): string[
     }
   }
   if ('max_rounds' in updates) {
-    if (typeof updates.max_rounds !== 'number' || !Number.isInteger(updates.max_rounds) || updates.max_rounds < 1) {
-      errors.push('updates.max_rounds must be a positive integer')
+    if (
+      typeof updates.max_rounds !== 'number' || !Number.isInteger(updates.max_rounds) ||
+      updates.max_rounds < 1 || updates.max_rounds > MAX_MAX_ROUNDS
+    ) {
+      errors.push(`updates.max_rounds must be an integer between 1 and ${MAX_MAX_ROUNDS}`)
     }
   }
   if ('review' in updates) {
@@ -62,11 +105,11 @@ export function validateConfigUpdates(updates: Record<string, unknown>): string[
     if (!a || typeof a !== 'object') {
       errors.push('updates.atomic must be an object')
     } else {
-      if (a.max_lines !== undefined && (typeof a.max_lines !== 'number' || !Number.isInteger(a.max_lines) || a.max_lines < 1)) {
-        errors.push('updates.atomic.max_lines must be a positive integer')
+      if (a.max_lines !== undefined && (typeof a.max_lines !== 'number' || !Number.isInteger(a.max_lines) || a.max_lines < 1 || a.max_lines > MAX_ATOMIC_MAX_LINES)) {
+        errors.push(`updates.atomic.max_lines must be an integer between 1 and ${MAX_ATOMIC_MAX_LINES}`)
       }
-      if (a.max_adjacent_methods !== undefined && (typeof a.max_adjacent_methods !== 'number' || a.max_adjacent_methods < 0)) {
-        errors.push('updates.atomic.max_adjacent_methods must be a non-negative number')
+      if (a.max_adjacent_methods !== undefined && (typeof a.max_adjacent_methods !== 'number' || a.max_adjacent_methods < 0 || a.max_adjacent_methods > MAX_MAX_ADJACENT_METHODS)) {
+        errors.push(`updates.atomic.max_adjacent_methods must be a number between 0 and ${MAX_MAX_ADJACENT_METHODS}`)
       }
     }
   }
@@ -168,7 +211,10 @@ export function readRawConfig(configPath: string): Record<string, unknown> {
   } catch {
     throw new Error('existing iterate.config.yaml is not a valid YAML mapping')
   }
-  if (!parsed || typeof parsed !== 'object') {
+  // A YAML sequence root (array) must not masquerade as a config object —
+  // `typeof [] === 'object'`, so the presence check alone would accept a
+  // config file that is actually a list. Writing over it would destroy data.
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
     throw new Error('existing iterate.config.yaml is not a valid YAML mapping')
   }
   return parsed as Record<string, unknown>
@@ -207,5 +253,9 @@ export function writeConfigFile(
     return { ok: false, 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, backupPath }
 }

package/src/evidence.ts

@@ -125,8 +125,36 @@ export function verifyFinding(
   input: Locatable,
   opts: { readSet?: Set<string> } = {},
 ): FindingEvidence {
-  const relFile = input.file ?? ''
+  // A null element / non-object finding (hostile or model-authored JSON) must
+  // be reported as poisoned evidence, never crash `path.resolve` downstream.
+  if (!input || typeof input !== 'object') {
+    return {
+      file: '',
+      line: null,
+      lineTotal: null,
+      resolvedPath: null,
+      verified: false,
+      error: 'file_not_found',
+    }
+  }
+  // A non-string `file` (number, object, …) would make `resolve` throw
+  // ERR_INVALID_ARG_TYPE — coerce to "" so it fails closed as not-found.
+  const relFile = typeof input.file === 'string' ? input.file : ''
   const line = typeof input.line === 'number' ? input.line : null
+
+  // "" resolves to the project ROOT (resolve(root, '') === root), which then
+  // trips the not-a-regular-file branch as `line_out_of_range` — but there is
+  // no file reference at all. Report it as `file_not_found` upfront.
+  if (relFile === '') {
+    return {
+      file: '',
+      line,
+      lineTotal: null,
+      resolvedPath: null,
+      verified: false,
+      error: 'file_not_found',
+    }
+  }
   const resolved = resolveWithin(root, relFile)
 
   if (resolved === null || !existsSync(resolved)) {