iterate-plugin 2.10.0 → 2.11.0

package/src/tools/prune.ts

@@ -18,7 +18,7 @@
  *   - Each deletion is logged to the decision log (when not dry-run).
  */
 
-import { existsSync, readdirSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
+import { existsSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-session'
@@ -134,17 +134,17 @@ export function executePrune(
     errors: [] as string[],
   }
 
-  // 1. Rewrite the decision log, keeping only recent entries.
+  // 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) {
-      writeFileSync(
-        join(iterateDir(projectRoot), 'decision-log.jsonl'),
-        kept.map((e) => JSON.stringify(e)).join('\n') + '\n',
-        'utf-8',
-      )
+      const logPath = join(iterateDir(projectRoot), 'decision-log.jsonl')
+      const tmpPath = `${logPath}.tmp-${Date.now()}`
+      writeFileSync(tmpPath, kept.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8')
+      renameSync(tmpPath, logPath)
     }
   } catch (err) {
     result.errors.push(`failed to rewrite decision log: ${String(err)}`)
@@ -175,10 +175,13 @@ export function executePrune(
   if (report.emptyRounds.length > 0) {
     try {
       let registry = readRegistry(projectRoot)
-      for (const round of report.emptyRounds) {
-        for (const rec of [...registry.rounds.find((r) => r.round === round)?.records ?? []]) {
-          registry = removeRecord(registry, rec.id)
-        }
+      const emptyRoundNos = new Set(report.emptyRounds)
+      // Drop whole empty rounds (records.length === 0) instead of only
+      // removing their records — an empty round has no records to remove, so
+      // the old loop was a no-op that still reported trimmedEmptyRounds.
+      registry = {
+        ...registry,
+        rounds: registry.rounds.filter((r) => !emptyRoundNos.has(r.round) || (r.records?.length ?? 0) > 0),
       }
       registry = recomputeRoundCounts(registry)
       writeFileSync(fixRegistryPath(projectRoot), JSON.stringify(registry, null, 2), 'utf-8')

package/src/tools/review.ts

@@ -170,9 +170,12 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
           const rawRounds = Array.isArray(args.rounds) ? args.rounds : []
           const rounds: ReviewRound[] = rawRounds
             .map((r) => {
-              const rr = r as { round?: number; findings?: unknown }
+              const rr = r as { round?: number; findings?: unknown; readFiles?: unknown }
               const findings = Array.isArray(rr?.findings) ? (rr.findings as ReviewFinding[]) : []
-              return { round: typeof rr?.round === 'number' ? rr.round : 0, findings }
+              const readFiles = Array.isArray(rr?.readFiles)
+                ? (rr.readFiles as unknown[]).filter((f): f is string => typeof f === 'string')
+                : []
+              return { round: typeof rr?.round === 'number' ? rr.round : 0, findings, readFiles }
             })
             .filter((r: ReviewRound) => r.round > 0)
 

package/src/tools/triage.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { copyFileSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-session'
@@ -231,16 +231,19 @@ function applyEntries(
   try {
     writeFileSync(configPath, yamlText, 'utf-8')
   } catch (err) {
-    // Rollback: restore the backup (or delete the file we just created).
+    // Rollback: restore the backup, or REMOVE the file we just created when
+    // there was no prior config — an empty file left behind would poison all
+    // future config reads (empty YAML is not a valid mapping).
+    let rollbackError = ''
     try {
       if (backupPath) copyFileSync(backupPath, configPath)
-      else if (existsSync(configPath)) writeFileSync(configPath, '', 'utf-8')
-    } catch {
-      // Rollback failure is reported, not swallowed silently.
+      else if (existsSync(configPath)) rmSync(configPath, { force: true })
+    } catch (rbErr) {
+      rollbackError = `; rollback also failed: ${String(rbErr)}`
     }
     return {
       ok: false,
-      error: `Failed to write config: ${String(err)}`,
+      error: `Failed to write config: ${String(err)}${rollbackError}`,
     }
   }
 

package/src/tools/validate.ts

@@ -46,10 +46,13 @@ async function runCommand(
       },
       (error, stdout, stderr) => {
         const durationMs = Math.round(performance.now() - start)
-        // error.code is the exit code when the command ran; error.killed means timeout
+        // error.code is the exit code when the command ran; when the binary
+        // cannot be spawned Node sets error.code to a STRING ('ENOENT' etc).
+        // Coerce to a number so the integer output schema is never violated.
+        const exitCode = typeof error?.code === 'number' ? error.code : (error ? 1 : 0)
         resolve({
           command,
-          exitCode: error?.code ?? (error ? 1 : 0),
+          exitCode,
           stdout: stdout ?? '',
           stderr: stderr ?? '',
           timedOut: error?.killed === true,

package/src/types.ts

@@ -76,6 +76,11 @@ export interface ReviewReport {
   rounds: ReviewRound[]
   /** Globally deduped, known-intentional-filtered, severity-sorted findings. */
   findings: ReviewFinding[]
+  /**
+   * Every file the reviewers self-reported opening (readFiles across rounds).
+   * Consumed by the meta-review coverage gate. Optional for back-compat.
+   */
+  readFiles?: string[]
   convergence: {
     totalRounds: number
     findingsByRound: number[]
@@ -98,6 +103,13 @@ export interface ReviewReport {
 export interface ReviewRound {
   round: number
   findings: ReviewFinding[]
+  /**
+   * Files the reviewer subagents actually opened with read_file (from their
+   * `readFiles` output). Threaded through aggregate → report → meta-review so
+   * the coverage gate can compare self-reported reads against the assigned
+   * inventory. Optional — older callers omit it.
+   */
+  readFiles?: string[]
 }
 
 /** Known intentional entry (filtered out from findings) */