iterate-plugin 3.3.1 → 3.4.1

package/README.md

@@ -255,8 +255,8 @@ validation:
 - `iterate_fix` — apply **one atomic fix**: validates the relative path, backs up the original file, enforces atomicity via `atomic.max_lines` (skippable with `force`), writes new content, records a FixRecord and an `atomic_fix` log. The only legal file-modifying entry in normal mode
 - `iterate_diff` — view accumulated fix changes: with `file`, returns the unified diff against the first backup; without it, a per-fixed-file summary
 - `iterate_rollback` — roll back an applied fix: restore the file from backup, remove that FixRecord from the registry, append a `revert` log. Used after a failed round validation
-- `iterate_checkpoint` — iteration breakpoint: `save` persists progress to `.iterate/checkpoint.json`, `load` reads it back, `clear` removes it. Resumable interrupted long iterations
-- `iterate_status` — summarize current iteration state: mode, current/last round, fixes applied, remaining architectural, decision-log entry count, whether a checkpoint exists
+- `iterate_checkpoint` — iteration breakpoint: `save` persists progress to `.iterate/checkpoint.json`, `load` reads it back, `resume` loads + bumps the resume counter (interruption recovery), `clear` removes it. Resumable interrupted long iterations
+- `iterate_status` — summarize current iteration state: mode, current/last round, fixes applied, remaining architectural, decision-log entry count, whether a checkpoint exists; **v3.4: also surfaces the persisted quality-gate snapshot, experience-bank summary, and defense-events summary** (`qualityGate` / `experienceBank` / `defenseEvents`)
 - `iterate_history` — read iteration history (read-only): decision-log entries (filter by `type` / `since` / `limit`, default latest 50, cap 200) + fix-registry summary (per-round fixed/failed counts). For auditing the run, tracing logs, and inventorying fixes
 - `iterate_prune` — clean runtime artifacts: stale decision-log entries (by `retainDays`, default 30), stale checkpoints, orphaned fix backups, empty rounds. Dry-run by default (report-only); real cleanup with `dryRun:false`, each cleanup logged
 - `iterate_transcript` — runtime observatory: persist review transcripts, threads, fixes, and nudge directions to `.iterate/transcript.json` for the client observatory
@@ -292,9 +292,20 @@ All runtime state lives under `.iterate/` at the project root (can be excluded v
 
 - **Node.js**: `>=20` (`package.json` `engines.node`).
 - **DSH**: declares `dsh.compatibility.dshReleases` — `compatible` for the official
-  `0.1.2-alpha.4`, `0.1.2-alpha.5`, and `0.1.2-rc.1` releases. The plugin is built
-  against `@deepseek-ai/dsh-tools` / `@deepseek-ai/dsh-util-values` `0.1.2-rc.1`
-  and uses only public contracts (tool registration, client slots + theme, bundle patch).
+  `0.1.1-rc.1`, `0.1.2-alpha.4`, `0.1.2-alpha.5`, `0.1.2-rc.1`, and `0.1.3-alpha.1`
+  releases. The plugin is built against `@deepseek-ai/dsh-tools` /
+  `@deepseek-ai/dsh-util-values` `0.1.2-rc.1` and uses only public contracts
+  (tool registration, client slots + theme, bundle patch). `0.1.3-alpha.1` is a
+  source declaration matching the current DSH release window; it does not use any
+  API changed by that release.
+- **Disposable-Profile evidence (real, `dsh` CLI `0.1.1-rc.1`)**: on a temp
+  `$DSH_HOME`, `dsh plugin --profile <p> add <this-repo>` installed the bundle in
+  ~449 ms; `dsh --profile <p> --dump-config` composed the `iterate-plugin` bundle
+  patch into the profile; `dsh plugin --profile <p> remove iterate-plugin`
+  uninstalled in ~602 ms and left zero references in the composed config. A full
+  runtime boot was **not** exercised here (no model provider in the disposable
+  profile), so `dshOperations` start/rollback stay `unknown`/`partial` — see
+  `CHANGELOG.md` for the exact commands and timings.
 
 ### Runtime permissions (conservative disclosure)
 
@@ -308,10 +319,14 @@ following capabilities; elevated capability means a DSH Profile install stays
   in-place edits to the user's source files (path-traversal protected to the
   resolved project root, backups taken before every fix, rollback on failure).
   The client half persists triage verdicts to `localStorage`.
-- **Commands** — the plugin registers model-facing tools; any shell execution that
-  the model performs (build / test / `git`) is run by the **host**, not by this
-  plugin. The client "command buttons" only copy paste-able instruction text; they
-  do not spawn processes.
+- **Commands** — the plugin's own tools execute a small, strictly bounded command
+  surface inside the dsh host process, only when the model calls them: `iterate_validate`
+  runs one of the **exact-match whitelisted** commands configured in
+  `iterate.config.yaml` `validation.commands` (yes, it shells out via
+  `node:child_process`, timeout-capped to ≤600 s); `iterate_review` (changed-only
+  scope) runs `git diff --name-only -z <branch>` in the project root. Nothing else
+  spawns a process. The client "command buttons" only copy paste-able instruction
+  text; they do not spawn processes.
 - **Credentials** — this plugin does **not** read or transmit credentials at
   runtime. The sibling **iterate-skill / iterate-harness** components may read git
   credentials / GitHub tokens when the user runs their own Git/API operations; those

package/README.zh-CN.md

@@ -254,8 +254,8 @@ validation:
 - `iterate_fix` — 应用**一个原子修复**：校验相对路径、备份原文件、按 `atomic.max_lines` 强制原子性（可 `force` 跳过）、写入新内容、记录 FixRecord 与 `atomic_fix` 日志。normal 模式唯一合法的改文件入口
 - `iterate_diff` — 查看修复累积变更：指定 `file` 返回相对首个备份的 unified diff；省略则返回每个已修复文件的汇总
 - `iterate_rollback` — 回滚一个已应用的修复：从备份还原文件、从注册表移除该 FixRecord、追加 `revert` 日志。用于某轮验证失败后
-- `iterate_checkpoint` — 迭代断点：`save` 保存当前进度到 `.iterate/checkpoint.json`，`load` 读回，`clear` 清除。长迭代可中断续跑
-- `iterate_status` — 汇总当前迭代状态：模式、当前轮/总轮、已修复数、剩余 architectural、决策日志条数、是否存在 checkpoint
+- `iterate_checkpoint` — 迭代断点：`save` 保存当前进度到 `.iterate/checkpoint.json`，`load` 读回，`resume` 加载并累加恢复计数（中断恢复），`clear` 清除。长迭代可中断续跑
+- `iterate_status` — 汇总当前迭代状态：模式、当前轮/总轮、已修复数、剩余 architectural、决策日志条数、是否存在 checkpoint；**v3.4：同时返回持久化的质量门禁快照、经验银行摘要与防御事件摘要**（`qualityGate` / `experienceBank` / `defenseEvents`）
 - `iterate_history` — 读取迭代历史（只读）：决策日志条目（可按 `type` / `since` / `limit` 过滤，默认取最新 50 条，上限 200 条）+ 修复注册表汇总（各轮 fixed/failed 计数）。用于审查运行过程、审计日志、盘点修复
 - `iterate_prune` — 清理运行时产物：过期决策日志条目（按 `retainDays`，默认 30 天）、陈旧断点、孤儿修复备份、空轮次。默认 dry-run 只报告不删除；`dryRun:false` 才真正清理，每次清理写入决策日志
 - `iterate_transcript` — 运行时观测台：把审查转录、线程、修复与 nudge 指令持久化到 `.iterate/transcript.json`，供客户端观测台读取
@@ -290,10 +290,17 @@ validation:
 ### Node.js / DSH 兼容范围
 
 - **Node.js**：`>=20`（`package.json` 的 `engines.node`）。
-- **DSH**：在 `dsh.compatibility.dshReleases` 中声明官方 `0.1.2-alpha.4`、
-  `0.1.2-alpha.5`、`0.1.2-rc.1` 三个版本为 `compatible`。插件基于
-  `@deepseek-ai/dsh-tools` / `@deepseek-ai/dsh-util-values` `0.1.2-rc.1` 构建，
-  只使用公开契约（工具注册、客户端 slots + theme、bundle patch）。
+- **DSH**：在 `dsh.compatibility.dshReleases` 中声明官方 `0.1.1-rc.1`、
+  `0.1.2-alpha.4`、`0.1.2-alpha.5`、`0.1.2-rc.1`、`0.1.3-alpha.1` 五个版本为
+  `compatible`。插件基于 `@deepseek-ai/dsh-tools` / `@deepseek-ai/dsh-util-values`
+  `0.1.2-rc.1` 构建，只使用公开契约（工具注册、客户端 slots + theme、bundle patch）；
+  `0.1.3-alpha.1` 为匹配当前 DSH 发布窗口的源码声明，插件不使用该发布变更的任何 API。
+- **一次性 Profile 证据（真实，`dsh` CLI `0.1.1-rc.1`）**：在临时 `$DSH_HOME` 下
+  `dsh plugin --profile <p> add <本仓库>` 约 449ms 完成安装；`dsh --profile <p>
+  --dump-config` 正确合成 `iterate-plugin` bundle patch；`dsh plugin --profile <p>
+  remove iterate-plugin` 约 602ms 卸载完成、合成配置中不存在残留引用。完整运行时
+  启动未在此环境演练（一次性 Profile 无模型提供方），故 `dshOperations` 的
+  start/rollback 证据为 `unknown`/`partial`——确切命令与耗时见 `CHANGELOG.md`。
 
 ### 运行时权限（保守披露）
 
@@ -304,9 +311,12 @@ validation:
   检查点、transcript、修复备份/注册表、质量门禁、经验银行、防御事件）。
   `iterate_fix` / `iterate_triage` 还会就地修改用户源码（路径遍历防护限定在解析后
   的项目根目录内，每次修复前备份、失败回滚）。客户端侧把分诊判定持久化到 `localStorage`。
-- **命令（commands）** — 插件只注册模型可调用工具；模型要执行的任何 shell 操作
-  （build / test / `git`）都由**宿主**执行，不是本插件。客户端"指挥按钮"只复制可粘贴
-  的指令文本，不启动任何进程。
+- **命令（commands）** — 插件的工具本身只执行一个严格受限的命令面、且仅在模型调用时
+  于 dsh 宿主进程内运行：`iterate_validate` 运行 `iterate.config.yaml`
+  `validation.commands` 中**逐条精确匹配白名单**的命令（是的，经由
+  `node:child_process` 执行，超时上限 600 秒）；`iterate_review`（changed-only 范围）
+  在项目根目录运行 `git diff --name-only -z <branch>`。除此之外不启动任何进程。
+  客户端"指挥按钮"只复制可粘贴的指令文本，不启动任何进程。
 - **凭据（credentials）** — 本插件运行时**不**读取或传输凭据。同生态的
   **iterate-skill / iterate-harness** 组件在用户自行执行 Git/API 操作时可能读取
   git 凭据 / GitHub token；它们是独立包，本插件从不加载它们。

package/dist/config-write.js

@@ -91,6 +91,27 @@ export function validateConfigUpdates(updates) {
             errors.push('updates.validation.commands must be an object of command arrays');
         }
     }
+    if ('observatory' in updates) {
+        const o = updates.observatory;
+        if (!o || typeof o !== 'object') {
+            errors.push('updates.observatory must be an object');
+        }
+        else {
+            if (o.capture !== undefined && typeof o.capture !== 'boolean') {
+                errors.push('updates.observatory.capture must be a boolean');
+            }
+            // The approval policy is the AUTHORITATIVE human-consent seam for
+            // destructive iterate tools (session-hooks.ts reads it at call time).
+            // Letting the model flip it to `allow` via a config write would bypass
+            // the gate entirely, so model-driven approval changes are refused
+            // fail-closed — the value can only be set by editing the config file
+            // directly (a human action the approval seam can trust).
+            if ('approval' in o) {
+                errors.push('updates.observatory.approval cannot be changed through iterate_config — ' +
+                    'edit iterate.config.yaml directly (the approval gate is human-controlled)');
+            }
+        }
+    }
     if ('personalization' in updates && (!updates.personalization || typeof updates.personalization !== 'object')) {
         errors.push('updates.personalization must be an object');
     }
@@ -105,6 +126,12 @@ export function applyConfigUpdates(base, updates) {
     for (const [key, value] of Object.entries(updates)) {
         if (value === undefined)
             continue;
+        // Prototype-pollution guard (mirrors config-loader.mergeConfig): a
+        // caller-supplied `__proto__`/`constructor`/`prototype` key must never be
+        // plain-assigned — on a plain object `out['__proto__'] = value` would set
+        // the object's prototype instead of an own property.
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
         const baseValue = out[key];
         if (baseValue &&
             typeof baseValue === 'object' &&

package/dist/git-scope.js

@@ -22,7 +22,7 @@
  */
 import { execFile } from 'node:child_process';
 import { existsSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, sep } from 'node:path';
 /**
  * Parse `git diff --name-only -z` stdout into a list of relative paths.
  * Pure. NUL-delimited mode is machine-safe (handles any filename); when no
@@ -112,11 +112,12 @@ export function parseChangedFiles(stdout) {
  */
 export function filterExistingFiles(root, files) {
     const out = [];
+    const rootPrefix = root.endsWith(sep) ? root : root + sep;
     for (const rel of files) {
         if (rel.startsWith('/') || rel.includes('\0'))
             continue;
         const candidate = join(root, rel);
-        if (!candidate.startsWith(root + '/') && candidate !== root)
+        if (!candidate.startsWith(rootPrefix) && candidate !== root)
             continue;
         try {
             if (existsSync(candidate) && statSync(candidate).isFile())

package/dist/review-scope.js

@@ -21,7 +21,7 @@
  * cleanly; collectScopeFiles walks the filesystem.
  */
 import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 /** Relative-scope sentinel for whole-module findings. */
 export const WHOLE_FILE_LINE = 0;
 /** Source extensions a full-scope walk includes. */
@@ -124,8 +124,16 @@ function collectFull(root) {
                 continue;
             if (!sourceExt(entry.name))
                 continue;
-            const rel = abs.startsWith(root + SEP) ? abs.slice(root.length + 1) : abs;
-            out.push(rel.split(SEP).join(SEP));
+            // Derive the inventory path relative to the root via path.relative (then
+            // canonicalize separators). The old `abs.slice(root.length + 1)` string
+            // prefix was only correct on POSIX: on Windows path.join emits '\\' while
+            // this module's SEP is '/', so the prefix never matched and the ABSOLUTE
+            // path leaked into the inventory. path.relative is separator-agnostic and
+            // always yields a path strictly inside `root`.
+            const rel = normalizePath(relative(root, abs));
+            if (rel === '' || rel === '.' || rel.startsWith('../') || rel === '..')
+                continue;
+            out.push(rel);
         }
     }
     return out.sort();

package/dist/review.js

@@ -219,11 +219,17 @@ function summarize(findings) {
  */
 export function buildReviewReport(input) {
     // 1. Filter known-intentional per round (before cross-round dedupe).
-    const filteredRounds = input.rounds.map((r) => ({
+    const filteredRounds = input.rounds
+        .map((r) => ({
         round: typeof r?.round === 'number' ? r.round : 0,
         findings: filterKnownIntentional(Array.isArray(r?.findings) ? r.findings : [], input.knownIntentional),
         readFiles: Array.isArray(r?.readFiles) ? r.readFiles : [],
-    }));
+    }))
+        // Sort by round number so convergence math below (and the meta-review
+        // audit, which reads the LAST element as the highest round) never depends
+        // on the caller's array order. A resumed run that only passes [round 5]
+        // must be audited as round 5, not as "one round with no number".
+        .sort((a, b) => a.round - b.round);
     // 2. Cross-round dedupe + per-round "first seen" tracking.
     const { findings, findingsByRound } = aggregateRounds(filteredRounds, input.maxReviewRounds);
     // 3. Severity sort the global result.
@@ -234,7 +240,11 @@ export function buildReviewReport(input) {
     //    using its reported round number — NOT `filteredRounds.length - 1`, which
     //    is only valid for contiguous 1..N round numbers (resumed iterations and
     //    non-contiguous round sets would otherwise read the wrong count).
-    const lastRound = filteredRounds.length > 0 ? filteredRounds[filteredRounds.length - 1].round : 0;
+    let lastRound = 0;
+    for (const r of filteredRounds) {
+        if (typeof r.round === 'number' && r.round > lastRound)
+            lastRound = r.round;
+    }
     const lastRoundCount = lastRound > 0 ? (findingsByRound[lastRound - 1] ?? 0) : 0;
     const converged = filteredRounds.length > 0 && lastRoundCount === 0;
     // Attach the normal-mode fix count to the summary (dry-run leaves it absent).

package/dist/skill-prompt.js

@@ -142,9 +142,20 @@ for (let r = 1; r <= maxRounds; r++) {
   // Feed the DEDUPED + already-filtered set back (not raw findings) so the known
   // list stays bounded and reviewers never see the same issue twice.
   if (agg && agg.report && Array.isArray(agg.report.findings)) known = agg.report.findings
-  if (agg && agg.report && agg.report.convergence && agg.report.convergence.findingsByRound[r-1] === 0) {
-    log('round ' + r + ' found 0 new findings — converged')
-    break
+  // A round counts as "converged" ONLY when the aggregate accepted it
+  // (schema-valid) AND it genuinely found zero NEW findings. If reviewers all
+  // failed or their output stayed schema-invalid after retries, the round is
+  // INCONCLUSIVE — never report an empty-but-broken round as converged (an
+  // invalid/failed round must fail the run, not masquerade as a clean pass).
+  if (!schemaInvalid) {
+    const newCount =
+      agg && agg.report && agg.report.convergence
+        ? agg.report.convergence.findingsByRound[r - 1]
+        : thisRound.findings.length
+    if (newCount === 0) {
+      log('round ' + r + ' found 0 new findings — converged')
+      break
+    }
   }
 }
 
@@ -237,7 +248,7 @@ if (checkpoint) {
 
 phase('plan')
 const configRes = await agent(
-  'Call iterate_config({ validate: true }) and return the config JSON.',
+  'Call iterate_config({}) and return the config JSON.',
   Object.assign({ label: 'config:read' }, backend)
 )
 const cfg = (configRes && configRes.config) ? configRes.config : null
@@ -420,7 +431,7 @@ for (let r = startRound; r <= maxRounds; r++) {
     Object.assign({ label: 'checkpoint:save:r' + r }, backend)
   )
 
-  if (atomic.length === 0 && remaining.length === 0) {
+  if (atomic.length === 0 && remaining.length === 0 && !schemaInvalid) {
     log('round ' + r + ' found nothing to fix — converged')
     converged = true
     break

package/dist/tools/checkpoint.js

@@ -14,6 +14,9 @@ import { resolveProjectRootForExec } from "../config-loader.js";
 import { checkpointPath, iterateDir, transcriptPath } from "../paths.js";
 import { readRegistry } from "./fix.js";
 import { readDecisionEntries } from "./decision-log.js";
+import { readQualityGate } from "./quality-store.js";
+import { readExperienceBank } from "./experience-store.js";
+import { readDefenseEvents } from "./defense-store.js";
 // ─── Pure helpers (exported for unit tests) ─────────────────────────────────
 /** Read the current checkpoint from disk (missing/corrupt → null). */
 export function readCheckpoint(projectRoot) {
@@ -116,6 +119,12 @@ export function computeStatus(input) {
         resumeCount: checkpoint?.resumeCount ?? 0,
         checkpoint,
         lastUpdated,
+        // v3.0: quality command-center snapshots (present only when the caller
+        // supplied a real snapshot — the status never fabricates one that is not
+        // on disk, and never emits null for an absent optional field).
+        ...(input.qualityGate != null ? { qualityGate: input.qualityGate } : {}),
+        ...(input.experienceBank != null ? { experienceBank: input.experienceBank } : {}),
+        ...(input.defenseEvents != null ? { defenseEvents: input.defenseEvents } : {}),
     };
 }
 // ─── iterate_checkpoint ──────────────────────────────────────────────────────
@@ -126,14 +135,16 @@ export function computeStatus(input) {
 export function registerCheckpointTool(ctx) {
     ctx.tools.register(defineTool({
         name: 'iterate_checkpoint',
-        description: 'Save / load / clear the iteration checkpoint. The workflow saves a checkpoint at the start of ' +
-            'each round (so a long run can resume) and clears it when the iteration completes.',
+        description: 'Save / load / resume / clear the iteration checkpoint. The workflow saves a checkpoint at the start of ' +
+            'each round (so a long run can resume) and clears it when the iteration completes. ' +
+            '`resume` loads an existing checkpoint, bumps its resumeCount, and persists it back — ' +
+            'call it when continuing an interrupted run so the resume counter stays accurate.',
         parameters: {
             operation: {
                 type: 'string',
                 required: true,
-                description: '"save" to persist the current progress, "load" to read it back, "clear" to remove it.',
-                enum: ['save', 'load', 'clear'],
+                description: '"save" to persist the current progress, "load" to read it back, "resume" to load + count a resumption, "clear" to remove it.',
+                enum: ['save', 'load', 'resume', 'clear'],
             },
             mode: { type: 'string', description: 'Required for save: "dry-run" or "normal".' },
             round: { type: 'integer', description: 'Required for save: current round number (0 = none started).' },
@@ -169,6 +180,28 @@ export function registerCheckpointTool(ctx) {
                 const checkpoint = readCheckpoint(projectRoot);
                 return { operation: 'load', ok: true, checkpoint: checkpoint };
             }
+            if (args.operation === 'resume') {
+                const current = readCheckpoint(projectRoot);
+                if (!current) {
+                    return { operation: 'resume', ok: false, error: 'no checkpoint to resume — run `save` first' };
+                }
+                const resumed = {
+                    ...current,
+                    resumeCount: (current.resumeCount ?? 0) + 1,
+                    updatedAt: new Date().toISOString(),
+                };
+                try {
+                    mkdirSync(iterateDir(projectRoot), { recursive: true });
+                    const cpPath = checkpointPath(projectRoot);
+                    const tmpPath = `${cpPath}.tmp-${Date.now()}`;
+                    writeFileSync(tmpPath, JSON.stringify(resumed, null, 2), 'utf-8');
+                    renameSync(tmpPath, cpPath);
+                }
+                catch (err) {
+                    return { operation: 'resume', ok: false, error: `failed to persist resumed checkpoint: ${String(err)}` };
+                }
+                return { operation: 'resume', ok: true, checkpoint: resumed };
+            }
             if (args.operation === 'clear') {
                 const existed = existsSync(checkpointPath(projectRoot));
                 if (existed) {
@@ -217,7 +250,7 @@ export function registerCheckpointTool(ctx) {
                 }
                 return { operation: 'save', ok: true, checkpoint: checkpoint };
             }
-            return { operation: args.operation, ok: false, error: 'unknown operation. Use "save", "load", or "clear".' };
+            return { operation: args.operation, ok: false, error: 'unknown operation. Use "save", "load", "resume", or "clear".' };
         },
     }));
 }
@@ -252,6 +285,9 @@ export function registerStatusTool(ctx) {
                     interrupted: { type: 'boolean', description: 'True when a checkpoint exists, meaning the previous run was interrupted before finishing.' },
                     resumeCount: { type: 'integer', description: 'How many times the current checkpoint has already been resumed.' },
                     lastUpdated: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+                    qualityGate: { type: 'json', description: 'v3.0: persisted quality-gate snapshot (.iterate/quality-gate.json), when present.' },
+                    experienceBank: { type: 'json', description: 'v3.0: experience bank summary (.iterate/experience.json), when present.' },
+                    defenseEvents: { type: 'json', description: 'v3.0: defense events summary (.iterate/defense-events.json), when present.' },
                     error: { type: 'string' },
                 },
             },
@@ -275,11 +311,30 @@ export function registerStatusTool(ctx) {
             if (!resolved.ok)
                 return { ok: false, error: resolved.reason };
             const projectRoot = resolved.root;
+            // v3.0: surface the persisted quality command-center snapshots so a
+            // single `iterate_status` call reports the whole run state — the gate,
+            // the experience bank, and the defense event stream. Each read is
+            // defensive (missing/malformed files yield an empty snapshot), so the
+            // status never crashes on absent artifacts.
+            const qualityGate = readQualityGate(projectRoot);
+            const experienceBank = readExperienceBank(projectRoot);
+            const defenseEvents = readDefenseEvents(projectRoot);
             const status = computeStatus({
                 checkpoint: readCheckpoint(projectRoot),
                 taskMode: readTranscriptTaskMode(projectRoot),
                 decisionEntries: readDecisionEntries(projectRoot),
                 fixRegistry: readRegistry(projectRoot),
+                qualityGate: qualityGate.dimensions.length > 0 || qualityGate.overallStatus === 'pass' || qualityGate.overallStatus === 'fail'
+                    ? qualityGate
+                    : null,
+                experienceBank: {
+                    totalEntries: experienceBank.entries.length,
+                    totalHits: experienceBank.totalHits ?? 0,
+                },
+                defenseEvents: {
+                    totalEvents: defenseEvents.events.length,
+                    counts: defenseEvents.counts,
+                },
             });
             return {
                 ok: true,
@@ -295,6 +350,9 @@ export function registerStatusTool(ctx) {
                 interrupted: status.interrupted,
                 resumeCount: status.resumeCount,
                 lastUpdated: status.lastUpdated ?? null,
+                qualityGate: status.qualityGate ? status.qualityGate : null,
+                experienceBank: status.experienceBank ? status.experienceBank : null,
+                defenseEvents: status.defenseEvents ? status.defenseEvents : null,
             };
         },
     }));

package/dist/tools/defense-events.js

@@ -56,6 +56,9 @@ function validateRecordInput(args) {
     if (typeof args.outcome !== 'string' || !args.outcome.trim()) {
         errors.push('outcome is required');
     }
+    if (args.line !== undefined && (typeof args.line !== 'number' || !Number.isInteger(args.line) || args.line < 0)) {
+        errors.push('line must be a non-negative integer when present');
+    }
     const severity = args.severity;
     if (severity !== 'critical' && severity !== 'high' && severity !== 'medium' && severity !== 'low') {
         errors.push('severity must be one of critical, high, medium, low');

package/dist/tools/defense-store.js

@@ -37,14 +37,25 @@ function emptyStream() {
         },
     };
 }
-/** Read the defense events stream from disk. */
+/**
+ * Read the defense events stream from disk.
+ * Normalizes the persisted stream so a hand-edited / partial file can never
+ * produce NaN counts: `counts` is recomputed from the events when missing or
+ * malformed, and every type key is guaranteed present.
+ */
 export function readDefenseEvents(projectRoot) {
     const filePath = path.join(projectRoot, '.iterate', DEFENSE_EVENTS_FILE);
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
         const parsed = JSON.parse(content);
         if (parsed && Array.isArray(parsed.events)) {
-            return parsed;
+            const events = parsed.events.filter((e) => !!e && typeof e === 'object' && typeof e.type === 'string');
+            const counts = computeCounts(events);
+            return {
+                events,
+                lastUpdated: typeof parsed.lastUpdated === 'string' ? parsed.lastUpdated : emptyStream().lastUpdated,
+                counts,
+            };
         }
     }
     catch {
@@ -80,7 +91,10 @@ export function addDefenseEvent(stream, event) {
         timestamp: new Date().toISOString(),
         ...event,
     };
-    const newCounts = { ...stream.counts };
+    // Always recompute from the events array instead of mutating a possibly
+    // stale/malformed persisted `counts` object — guarantees the stream counts
+    // can never drift from (or NaN out against) its events.
+    const newCounts = computeCounts(stream.events);
     bumpCount(newCounts, event.type);
     return {
         events: [...stream.events, newEvent],

package/dist/tools/history.js

@@ -112,7 +112,7 @@ export function registerHistoryTool(ctx) {
                         ? `Fixes: ${fixes.totalFixed} applied · ${fixes.totalFailed} failed · across ${fixes.roundCount} round(s)`
                         : 'Fixes: none',
                     '',
-                    ...log.map((e) => `[${e.timestamp}] r${e.round} ${e.type}: ${JSON.stringify(e.data ?? {})}`),
+                    ...log.map((e) => `[${e.timestamp}] r${e.round ?? '?'} ${e.type}: ${JSON.stringify(e.data ?? {})}`),
                 ];
                 return [{ type: 'text', text: lines.join('\n') }];
             },

package/dist/tools/quality-store.js

@@ -26,14 +26,56 @@ function emptySnapshot() {
         lowCount: 0,
     };
 }
-/** Read the quality gate snapshot from disk. */
+/**
+ * Read the quality gate snapshot from disk.
+ * Normalizes a hand-edited / partial file so readers and the tool's `render`
+ * never crash on missing arrays or non-numeric fields: `dimensions` is
+ * guaranteed to be an array and every numeric field degrades to 0.
+ */
 export function readQualityGate(projectRoot) {
     const filePath = path.join(projectRoot, '.iterate', QUALITY_GATE_FILE);
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed === 'object') {
-            return parsed;
+            const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : 0;
+            const status = parsed.overallStatus === 'pass' || parsed.overallStatus === 'fail' || parsed.overallStatus === 'pending'
+                ? parsed.overallStatus
+                : 'pending';
+            const dimensions = Array.isArray(parsed.dimensions)
+                ? parsed.dimensions
+                    .filter((d) => !!d && typeof d === 'object' && typeof d.dimension === 'string')
+                    .map((d) => {
+                    const dimStatus = d.status === 'pass' || d.status === 'fail' || d.status === 'warn' ? d.status : 'warn';
+                    return {
+                        dimension: d.dimension,
+                        convergenceRate: num(d.convergenceRate),
+                        findingsCount: num(d.findingsCount),
+                        fixedCount: num(d.fixedCount),
+                        score: num(d.score),
+                        status: dimStatus,
+                    };
+                })
+                : [];
+            return {
+                timestamp: typeof parsed.timestamp === 'string' ? parsed.timestamp : emptySnapshot().timestamp,
+                overallStatus: status,
+                overallScore: num(parsed.overallScore),
+                dimensions,
+                verificationPassRate: num(parsed.verificationPassRate),
+                totalChecks: num(parsed.totalChecks),
+                passedChecks: num(parsed.passedChecks),
+                failedChecks: num(parsed.failedChecks),
+                totalFindings: num(parsed.totalFindings),
+                criticalCount: num(parsed.criticalCount),
+                highCount: num(parsed.highCount),
+                mediumCount: num(parsed.mediumCount),
+                lowCount: num(parsed.lowCount),
+                // Only carry an own failReason when it is a real string — an absent
+                // persisted reason must not surface as `failReason: undefined` (which
+                // deep-equals differently than the JSON round-trip of computeQualityGate).
+                ...(typeof parsed.failReason === 'string' ? { failReason: parsed.failReason } : {}),
+            };
         }
     }
     catch {

package/dist/transcript.js

@@ -32,6 +32,9 @@ const MAX_FINDINGS_PER_THREAD = 100;
 const MAX_FINDINGS_TOTAL = 2000;
 /** Max timeline entries kept (newest wins). */
 const MAX_TIMELINE = 500;
+/** Max applied-fix records kept (newest wins; bounded so a long run cannot
+ *  grow the manifest payload without limit). */
+const MAX_FIXES = 200;
 /** Thresholds applied when reducing a string list under a cap. */
 function clampStringList(source, cap) {
     const out = [];
@@ -271,6 +274,9 @@ export class ReviewTranscriptBuilder {
             linesRemoved: typeof record.linesRemoved === 'number' ? Math.floor(record.linesRemoved) : 0,
             success: record.success !== false,
         });
+        if (this.fixes.length > MAX_FIXES) {
+            this.fixes.splice(0, this.fixes.length - MAX_FIXES);
+        }
         this.touch();
     }
     /** Flag a fix as rolled back (kept in the list so the UI shows the reversal). */