iterate-plugin 3.5.5 → 3.5.7

package/src/transcript.ts

@@ -98,7 +98,10 @@ function normalizeFinding(input: unknown): TranscriptFinding | null {
     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,
@@ -267,7 +270,8 @@ 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]! as LiveRound | undefined
-    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,
@@ -275,7 +279,86 @@ export class ReviewTranscriptBuilder {
         readFiles: [],
         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: number,
+    thread: {
+      dimension?: unknown
+      attempt?: unknown
+      messages?: unknown
+      readFiles?: unknown
+      findings?: unknown
+    },
+  ): void {
+    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: LiveThread = {
+      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 as string[]))
+    }
+    if (Array.isArray(thread.findings)) {
+      for (const f of thread.findings) {
+        if (normalizeFinding(f)) pushThreadFinding(t, f)
+      }
     }
+    live.threads.push(t)
     this.touch()
   }
 

package/src/types.ts

@@ -18,9 +18,12 @@ export interface IterateConfig {
   }
   /**
    * LLM reasoning effort for review passes ('low' | 'medium' | 'high').
-   * Absent → follow the provider default. The harness forwards it into the
-   * OpenAI-compatible request body; the plugin surfaces it in the settings
-   * panel and review plan (dsh 0.1.1-rc.7+ exposes the same 'low' effort).
+   * Absent → follow the provider default. Accepted by `iterate_config` write
+   * validation (config-write), exposed in the settings guide, and carried on
+   * the review plan (`buildReviewPlan.reasoningEffort`, plus an effort
+   * directive injected into every reviewer prompt) so the orchestrating
+   * harness can honor it per reviewer subagent. The plugin itself never reads
+   * or modifies the provider request body.
    */
   reasoning_effort?: 'low' | 'medium' | 'high'
   reviewer: {
@@ -226,7 +229,9 @@ export interface IterationStatus {
   findingsCount: number
   totalDecisionLogEntries: number
   hasCheckpoint: boolean
-  /** True when a checkpoint is present — i.e. the previous run was interrupted before finishing. */
+  /** True when a checkpoint is present AND no decision-log entry is newer than
+   *  it — i.e. the previous run left a checkpoint and nothing has logged since
+   *  (a live run that saved progress keeps `interrupted=false`). */
   interrupted: boolean
   /** How many times the current checkpoint has already been resumed. */
   resumeCount: number