iterate-plugin 3.5.1 → 3.5.3

package/src/tools/fix.ts

@@ -19,7 +19,7 @@
 
 import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs'
 import { writeJsonAtomic, writeTextAtomic } from '../atomic-fs.ts'
-import { join, sep } from 'node:path'
+import { dirname, join, sep } from 'node:path'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-util-values'
 import { loadEffectiveConfig, resolveProjectRootForExec } from '../config-loader.ts'
@@ -126,11 +126,25 @@ export function readRegistry(projectRoot: string): FixRegistry {
   try {
     const parsed = JSON.parse(readFileSync(file, 'utf-8')) as FixRegistry
     if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.rounds)) return emptyRegistry()
-    // Defensive: a hand-edited or partially-written registry may contain a
-    // round without a `records` array — normalize instead of crashing readers.
-    parsed.rounds = parsed.rounds.filter(
-      (r) => r && typeof r === 'object' && Array.isArray(r.records),
-    )
+    // Defensive normalization: a hand-edited or partially-written registry may
+    // contain a round without a `records` array, or records that are missing
+    // their id / finding object — all of which would make readers
+    // (findFixRecord / recordsForFile / iterate_diff) throw or sum NaN.
+    parsed.rounds = parsed.rounds
+      .filter((r) => r && typeof r === 'object' && Array.isArray(r.records))
+      .map((r) => ({
+        ...r,
+        round: typeof r.round === 'number' && Number.isFinite(r.round) ? Math.floor(r.round) : 0,
+        records: r.records.filter(
+          (rec): rec is FixRecord =>
+            !!rec &&
+            typeof rec === 'object' &&
+            typeof rec.id === 'string' &&
+            !!rec.finding &&
+            typeof rec.finding === 'object',
+        ),
+      }))
+      .filter((r) => typeof r.round === 'number' && Number.isFinite(r.round))
     return parsed
   } catch {
     return emptyRegistry()
@@ -207,15 +221,25 @@ export function resolveProjectFile(projectRoot: string, file: string): { ok: tru
     return { ok: false, reason: 'file resolves outside the project root' }
   }
   // Symlink containment: the lexical prefix check above does not resolve
-  // symlinks. If the target exists, verify its REAL path stays inside the REAL
-  // project root so a symlinked directory/file inside the repo can never route
-  // a fix (write/rollback/diff) outside the project.
-  if (existsSync(resolved)) {
+  // symlinks. Verify the REAL path of the target (when it exists) AND of its
+  // nearest existing ancestor directory (when it does not — e.g. a fix that
+  // creates a new file) stays inside the REAL project root, so a symlinked
+  // directory inside the repo can never route a fix (write/rollback/diff)
+  // outside the project. The probe stops at the project root itself: the root
+  // is harness-provided (not model-controlled), and a path with no existing
+  // entry inside the repo cannot hide a symlink.
+  let probe = resolved
+  while (!existsSync(probe) && probe !== projectRoot) {
+    const parent = dirname(probe)
+    if (parent === probe) break
+    probe = parent
+  }
+  if (existsSync(probe)) {
     let rootReal: string
     let real: string
     try {
       rootReal = realpathSync(projectRoot)
-      real = realpathSync(resolved)
+      real = realpathSync(probe)
     } catch {
       return { ok: false, reason: 'failed to resolve real path for containment check' }
     }
@@ -492,9 +516,9 @@ export function registerFixTool(ctx: { tools: { register: (def: ReturnType<typeo
           // Registry write failed → the file was already modified but no record
           // exists, so a later rollback/diff could never see it and a retry would
           // back up the already-fixed content as "original". Restore the file
-          // from the backup to leave the tree exactly as it was.
+          // from the backup atomically to leave the tree exactly as it was.
           try {
-            copyFileSync(backupPath, target.resolved)
+            writeTextAtomic(target.resolved, readFileSync(backupPath, 'utf-8'))
           } catch (restoreErr) {
             return {
               ok: false,
@@ -611,19 +635,25 @@ export function registerDiffTool(ctx: { tools: { register: (def: ReturnType<type
         for (const round of registry.rounds) {
           for (const r of round.records) {
             if (!r.success) continue
-            const existing = files.find((f) => f.file === r.finding.file)
+            const file = typeof r.finding.file === 'string' ? r.finding.file : ''
+            if (!file) continue
+            // Coerce defensively: a hand-edited registry record missing the
+            // numeric fields must not produce NaN in the accumulated summary.
+            const added = Number(r.linesAdded) || 0
+            const removed = Number(r.linesRemoved) || 0
+            const existing = files.find((f) => f.file === file)
             if (existing) {
-              existing.linesAdded += r.linesAdded
-              existing.linesRemoved += r.linesRemoved
+              existing.linesAdded += added
+              existing.linesRemoved += removed
               // Recompute the summary from the summed counts so a multi-fix
               // file's text does not contradict its accumulated numbers.
               existing.diffSummary = `+${existing.linesAdded}/-${existing.linesRemoved} lines`
             } else {
               files.push({
-                file: r.finding.file,
-                diffSummary: r.diffSummary,
-                linesAdded: r.linesAdded,
-                linesRemoved: r.linesRemoved,
+                file,
+                diffSummary: typeof r.diffSummary === 'string' ? r.diffSummary : `+${added}/-${removed} lines`,
+                linesAdded: added,
+                linesRemoved: removed,
               })
             }
           }
@@ -705,7 +735,9 @@ export function registerRollbackTool(ctx: { tools: { register: (def: ReturnType<
         const target = resolveProjectFile(projectRoot, record.finding.file)
         if (!target.ok) return { ok: false, error: target.reason }
         try {
-          copyFileSync(record.backupPath, target.resolved)
+          // Atomic restore: never leave a truncated source file if we crash
+          // mid-restore (matches the writeTextAtomic guarantee used by apply).
+          writeTextAtomic(target.resolved, readFileSync(record.backupPath, 'utf-8'))
         } catch (err) {
           return { ok: false, error: `failed to restore backup: ${String(err)}` }
         }

package/src/tools/history.ts

@@ -60,8 +60,10 @@ export function summarizeFixRegistry(registry: FixRegistry): {
 } {
   const rounds = (registry.rounds ?? []).map((r) => ({
     round: r.round,
-    fixedCount: r.fixedCount,
-    failedCount: r.failedCount,
+    // Coerce defensively so a hand-edited registry round missing either count
+    // can never propagate NaN into the integer output fields.
+    fixedCount: Number(r.fixedCount) || 0,
+    failedCount: Number(r.failedCount) || 0,
   }))
   return {
     totalFixed: rounds.reduce((s, r) => s + r.fixedCount, 0),
@@ -92,7 +94,7 @@ export function registerHistoryTool(ctx: { tools: { register: (def: ReturnType<t
           type: 'string',
           description:
             'Optional entry-type filter: round_start, review_result, atomic_fix, architectural_fix, ' +
-            'revert, validation, decision, report.',
+            'revert, round_failed, validation, decision, report, resume.',
         },
         since: {
           type: 'string',

package/src/tools/prune.ts

@@ -106,16 +106,22 @@ export function inspectPrune(
   }
   const staleBackups: string[] = []
   const fixDir = fixesDir(projectRoot)
-  if (existsSync(fixDir)) {
-    for (const entry of readdirSync(fixDir)) {
-      if (!entry.endsWith('.bak')) continue
-      // Extract the fix-id prefix (up to the first underscore after the id).
-      // e.g. "fix-abc123_2026-08-17T00-00-00-000Z.bak" → "fix-abc123"
-      const match = entry.match(/^(fix-[a-z0-9]+)_/)
-      const id = match?.[1]
-      if (id && !activeIds.has(id)) {
-        staleBackups.push(entry)
-      }
+  // existsSync does not prove readability — a permissions failure must degrade
+  // to "nothing listable" (report skipped) instead of throwing out of execute.
+  let fixEntries: string[] = []
+  try {
+    if (existsSync(fixDir)) fixEntries = readdirSync(fixDir)
+  } catch {
+    fixEntries = []
+  }
+  for (const entry of fixEntries) {
+    if (!entry.endsWith('.bak')) continue
+    // Extract the fix-id prefix (up to the first underscore after the id).
+    // e.g. "fix-abc123_2026-08-17T00-00-00-000Z.bak" → "fix-abc123"
+    const match = entry.match(/^(fix-[a-z0-9]+)_/)
+    const id = match?.[1]
+    if (id && !activeIds.has(id)) {
+      staleBackups.push(entry)
     }
   }
 
@@ -126,10 +132,15 @@ export function inspectPrune(
 
   // 5. Stray atomic-write temp files left behind by a crashed writer. The
   // unique prefix makes them recognizable and safe to delete — no live writer
-  // ever reads another writer's temp file.
-  const staleTemps = existsSync(iterateDir(projectRoot))
-    ? readdirSync(iterateDir(projectRoot)).filter((f) => isPrunableTemp(f)).sort()
-    : []
+  // ever reads another writer's temp file. A permissions failure listing the
+  // dir degrades to "none found" (report-only) rather than throwing.
+  let iterateEntries: string[] = []
+  try {
+    iterateEntries = existsSync(iterateDir(projectRoot)) ? readdirSync(iterateDir(projectRoot)) : []
+  } catch {
+    iterateEntries = []
+  }
+  const staleTemps = iterateEntries.filter((f) => isPrunableTemp(f)).sort()
 
   return {
     oldLogEntries,

package/src/tools/quality-gate.ts

@@ -13,6 +13,9 @@ import { resolveProjectRootForExec } from '../config-loader.ts'
 import { readQualityGate, writeQualityGate, computeQualityGate, clearQualityGate } from './quality-store.ts'
 import type { QualityGateSnapshot } from '../types.ts'
 
+/** Valid severity values (kept in sync with QualityGateSnapshot counting). */
+const VALID_SEVERITIES: ReadonlySet<string> = new Set(['critical', 'high', 'medium', 'low'])
+
 /** Validate a single finding object; returns true when well-formed. */
 function isValidFinding(raw: unknown): raw is { dimension: string; severity: string; file: string; line?: number } {
   if (!raw || typeof raw !== 'object') return false
@@ -20,6 +23,7 @@ function isValidFinding(raw: unknown): raw is { dimension: string; severity: str
   return (
     typeof f.dimension === 'string' &&
     typeof f.severity === 'string' &&
+    VALID_SEVERITIES.has(f.severity) &&
     typeof f.file === 'string' &&
     (f.line === undefined || typeof f.line === 'number')
   )

package/src/tools/quality-store.ts

@@ -232,15 +232,20 @@ export function computeQualityGate(opts: {
     ? Math.round(dimensionGates.reduce((sum, d) => sum + d.score, 0) / dimensionGates.length)
     : 0
 
-  // Determine overall status
+  // Determine overall status. An empty review (no dimensions, no findings, no
+  // validation results) is NOT a failure — there is simply nothing to gate —
+  // so it reports `pending` (not-applicable) instead of a fabricated FAIL.
   const hasCritical = criticalCount > 0
   const hasHighFail = dimensionGates.some((d) => d.status === 'fail')
   const verificationFails = totalChecks > 0 && failedChecks > 0
+  const noData = dimensionGates.length === 0 && totalFindings === 0 && totalChecks === 0
 
   let overallStatus: 'pass' | 'fail' | 'pending' = 'pass'
   let failReason: string | undefined
 
-  if (hasCritical) {
+  if (noData) {
+    overallStatus = 'pending'
+  } else if (hasCritical) {
     overallStatus = 'fail'
     failReason = `${criticalCount} critical findings present`
   } else if (hasHighFail) {

package/src/tools/transcript.ts

@@ -44,7 +44,10 @@ function captureRound(builder: ReviewTranscriptBuilder, round: unknown): void {
     findings?: unknown
     readFiles?: unknown
   }
-  const roundNo = typeof r.round === 'number' ? Math.floor(r.round) : 0
+  const roundNo = typeof r.round === 'number' && Number.isFinite(r.round) ? Math.floor(r.round) : 0
+  // NaN round values (`Math.floor(NaN) === NaN`, and `NaN <= 0` is false) would
+  // fall through the guard below; a finite check rejects them outright so a
+  // malformed round can never collapse into round 1 via the builder's coercion.
   if (roundNo <= 0) return
   builder.roundStart(roundNo)
   const findings = Array.isArray(r.findings) ? r.findings : []
@@ -70,14 +73,16 @@ function captureRound(builder: ReviewTranscriptBuilder, round: unknown): void {
 function normalizeCheckpoint(input: unknown): TranscriptManifest['checkpoint'] {
   if (!input || typeof input !== 'object') return null
   const c = input as Record<string, unknown>
-  const round = typeof c.round === 'number' ? c.round : 0
+  // Number.isFinite: a NaN round must not pass `round <= 0` (which is false for
+  // NaN) and later coerce into a phantom round 1 row.
+  const round = typeof c.round === 'number' && Number.isFinite(c.round) ? c.round : 0
   if (round <= 0) return null
   return {
     mode: c.mode === 'dry-run' || c.mode === 'normal' ? c.mode : 'normal',
     round,
-    maxRounds: typeof c.maxRounds === 'number' ? c.maxRounds : 0,
-    fixedCount: typeof c.fixedCount === 'number' ? c.fixedCount : 0,
-    resumeCount: typeof c.resumeCount === 'number' ? c.resumeCount : 0,
+    maxRounds: typeof c.maxRounds === 'number' && Number.isFinite(c.maxRounds) ? c.maxRounds : 0,
+    fixedCount: typeof c.fixedCount === 'number' && Number.isFinite(c.fixedCount) ? c.fixedCount : 0,
+    resumeCount: typeof c.resumeCount === 'number' && Number.isFinite(c.resumeCount) ? c.resumeCount : 0,
     updatedAt: typeof c.updatedAt === 'string' ? c.updatedAt : new Date().toISOString(),
   }
 }
@@ -92,7 +97,7 @@ function normalizeFix(input: unknown): TranscriptFix | null {
   return {
     id,
     timestamp: typeof f.timestamp === 'string' ? f.timestamp : new Date().toISOString(),
-    round: typeof f.round === 'number' ? f.round : 0,
+    round: typeof f.round === 'number' && Number.isFinite(f.round) ? f.round : 0,
     file,
     summary: typeof f.summary === 'string' ? f.summary : '',
     linesAdded: typeof f.linesAdded === 'number' ? f.linesAdded : 0,
@@ -224,11 +229,24 @@ export function registerTranscriptTool(ctx: {
               manifest = null
             }
           }
-          const builder = manifest
-            ? rehydrateBuilder(manifest, approval)
-            : new ReviewTranscriptBuilder({ project: projectRoot, mode: 'normal', approval })
+          // 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.
+          let builder: ReviewTranscriptBuilder
+          if (manifest) {
+            try {
+              builder = rehydrateBuilder(manifest, approval)
+            } catch {
+              builder = new ReviewTranscriptBuilder({ project: projectRoot, mode: 'normal', approval })
+            }
+          } else {
+            builder = new ReviewTranscriptBuilder({ project: projectRoot, mode: 'normal', approval })
+          }
           builder.setNudge(typeof args.text === 'string' && args.text.trim() ? args.text : null)
-          await persist(file, builder.serialize())
+          const persisted = await persistChecked(file, builder.serialize())
+          if (!persisted.ok) {
+            return { operation: 'nudge', updated: false, error: persisted.error }
+          }
           return {
             operation: 'nudge',
             updated: true,
@@ -291,7 +309,10 @@ export function registerTranscriptTool(ctx: {
         const last = convergence[convergence.length - 1]
         if (convergence.length > 0 && last === 0) builder.finish()
 
-        await persist(file, builder.serialize())
+        const persisted = await persistChecked(file, builder.serialize())
+        if (!persisted.ok) {
+          return { operation: 'capture', found: true, updated: false, error: persisted.error }
+        }
         const live = await readLive(projectRoot)
         return {
           operation: 'capture',
@@ -342,6 +363,21 @@ async function persist(file: string, manifest: TranscriptManifest): Promise<void
   await writeTextAtomicAsync(file, JSON.stringify(manifest, null, 2))
 }
 
+/** persist wrapped with a structured error channel so disk failures surface
+ *  as a structured tool result instead of rejecting the whole execute (matches
+ *  every other write path in this codebase). */
+async function persistChecked(
+  file: string,
+  manifest: TranscriptManifest,
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  try {
+    await persist(file, manifest)
+    return { ok: true }
+  } catch (err) {
+    return { ok: false, error: `failed to persist transcript: ${err instanceof Error ? err.message : String(err)}` }
+  }
+}
+
 /**
  * Mark one applied fix as rolled back in the PERSISTED transcript, so the
  * client observatory (F4 fix/rollback tab) reflects the reversal instead of

package/src/transcript.ts

@@ -53,6 +53,11 @@ const MAX_TIMELINE = 500
  *  grow the manifest payload without limit). */
 const MAX_FIXES = 200
 
+/** Max round number accepted by the builder. A model-authored/manifest-backed
+ *  round value is attacker-influenced JSON: `roundStart(1e9)` / `snapshotConvergence`
+ *  would otherwise preallocate arrays of that size and OOM the host. */
+const MAX_ROUNDS = 1000
+
 /** Thresholds applied when reducing a string list under a cap. */
 function clampStringList(source: string[], cap: number): string[] {
   const out: string[] = []
@@ -207,9 +212,13 @@ export class ReviewTranscriptBuilder {
   /** Open a review round, capturing the current round index. */
   roundStart(round: number, maxRounds?: number): void {
     const r = typeof round === 'number' && Number.isFinite(round) ? Math.floor(round) : 1
-    this.round = r > 0 ? r : 1
+    // Clamp to MAX_ROUNDS: `this.rounds.length < this.round` below preallocates
+    // an array of size `round` — an unbounded model-controlled value (e.g. 1e9)
+    // would OOM the host. Values above the cap are folded into the cap so the
+    // real rounds are never silently dropped.
+    this.round = Math.min(r > 0 ? r : 1, MAX_ROUNDS)
     if (typeof maxRounds === 'number' && Number.isFinite(maxRounds) && maxRounds >= 0) {
-      this.maxRounds = Math.floor(maxRounds)
+      this.maxRounds = Math.min(Math.floor(maxRounds), MAX_ROUNDS)
     }
     while (this.rounds.length < this.round) {
       this.rounds.push({ round: this.rounds.length + 1, threads: [] })
@@ -294,7 +303,10 @@ export class ReviewTranscriptBuilder {
 
   /** Record a round's new-finding count for the convergence series. */
   snapshotConvergence(round: number, newCount: number): void {
-    const r = typeof round === 'number' && Number.isFinite(round) ? Math.floor(round) : 1
+    const rawR = typeof round === 'number' && Number.isFinite(round) ? Math.floor(round) : 1
+    // Clamp (mirrors roundStart): the loop below preallocates `r` slots, so an
+    // unbounded model-controlled round number would OOM the host.
+    const r = Math.min(rawR > 0 ? rawR : 1, MAX_ROUNDS)
     const n = typeof newCount === 'number' && Number.isFinite(newCount) ? newCount : 0
     while (this.convergence.length < r) this.convergence.push(-1)
     this.convergence[r - 1] = Math.floor(n)
@@ -312,7 +324,10 @@ export class ReviewTranscriptBuilder {
     this.fixes.push({
       id,
       timestamp: typeof record.timestamp === 'string' ? record.timestamp : isoNow(),
-      round: typeof record.round === 'number' ? record.round : this.round,
+      round:
+        typeof record.round === 'number' && Number.isFinite(record.round)
+          ? Math.floor(record.round)
+          : this.round,
       file,
       summary: typeof record.summary === 'string' ? record.summary : '',
       linesAdded:
@@ -363,7 +378,10 @@ export class ReviewTranscriptBuilder {
     const type = typeof entry.type === 'string' ? entry.type : 'decision'
     this.timeline.push({
       timestamp: typeof entry.timestamp === 'string' ? entry.timestamp : isoNow(),
-      round: typeof entry.round === 'number' ? entry.round : this.round,
+      round:
+        typeof entry.round === 'number' && Number.isFinite(entry.round)
+          ? Math.floor(entry.round)
+          : this.round,
       type,
       data:
         entry.data && typeof entry.data === 'object'