iterate-plugin 2.7.1 → 2.7.3

package/src/index.ts

@@ -2,11 +2,13 @@
  * iterate-plugin — dsh plugin for the iterate autonomous closed-loop workflow
  *
  * Architecture:
- * - The plugin registers 6 tools (config, validate, decision-log, context, review, triage)
+ * - The plugin registers 13 tools (config, validate, decision-log, context, review,
+ *   triage, fix, diff, rollback, checkpoint, status, history, prune)
  * - The plugin injects a system prompt section teaching the iterate workflow pattern
  * - The model (prompted by the skill) writes a workflow script using dsh's `workflow` tool
  * - The workflow script uses `agent()` / `parallel()` / `phase()` / `log()` to orchestrate
- * - Subagents use the 6 tools to do real work (read config, run validation, log decisions, review, triage)
+ * - Subagents use the 13 tools to do real work (read config, run validation, log decisions,
+ *   review, triage, apply/rollback/fixing, checkpoint, status, history, prune)
  *
  * Tool invocation model:
  * - Workflow script CANNOT call tools directly (sandboxed vm, no Node API)
@@ -16,7 +18,7 @@
  *
  * Key files:
  * - src/index.ts      — Plugin entry: register tools + inject skill prompt
- * - src/tools/        — 6 tool implementations + meta-review/review engines
+ * - src/tools/        — 13 tool implementations + meta-review/review engines
  * - src/config-loader.ts — YAML config loading
  * - src/types.ts     — Shared types
  */
@@ -38,7 +40,7 @@ export const name = 'iterate-plugin'
 export const inject = ['tools', 'systemPrompt']
 
 export function apply(ctx: Context): void {
-  // 1. Register the 11 tools
+  // 1. Register the 13 tools
   registerConfigTool(ctx)
   registerValidateTool(ctx)
   registerDecisionLogTool(ctx)

package/src/review.ts

@@ -218,6 +218,8 @@ export function buildReviewReport(input: {
   maxReviewRounds: number
   rounds: ReviewRound[]
   knownIntentional?: KnownIntentional[]
+  /** Number of atomic fixes applied so far. Normal mode only; omitted in dry-run. */
+  fixedCount?: number
 }): ReviewReport {
   // 1. Filter known-intentional per round (before cross-round dedupe).
   const filteredRounds = input.rounds.map((r) => ({
@@ -246,6 +248,12 @@ export function buildReviewReport(input: {
     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).
+  const computed = summarize(sorted)
+  if (input.mode === 'normal' && typeof input.fixedCount === 'number' && Number.isInteger(input.fixedCount)) {
+    computed.fixedCount = input.fixedCount
+  }
+
   return {
     mode: input.mode,
     goal: input.goal,
@@ -264,7 +272,7 @@ export function buildReviewReport(input: {
             ? 'converged'
             : 'max_rounds_reached',
     },
-    summary: summarize(sorted),
+    summary: computed,
   }
 }
 

package/src/skill-prompt.ts

@@ -14,13 +14,15 @@ You have the iterate plugin installed, which registers these tools:
 - \`iterate_validate\` — run a whitelisted validation command
 - \`iterate_decision_log\` — append to the decision log, or read entries back for review
 - \`iterate_context\` — read SKILL.md / ITERATE.md project context
-- \`iterate_review\` — deterministic review engine: \`plan\` builds the review plan; \`aggregate\` dedupes/merges findings and computes convergence. Purely computational.
+- \`iterate_review\` — deterministic review engine: \`plan\` builds the review plan; \`aggregate\` dedupes/merges findings and computes convergence; \`meta-review\` audits a built report for internal consistency (counts, buckets, sorting, convergence math) and returns a final report with an \`approved\` / \`needs_revision\` verdict. Purely computational.
 - \`iterate_triage\` — manage "known_intentional" entries in the config (list / apply, with dedupe + backup + rollback)
 - \`iterate_fix\` — apply ONE atomic fix: backs up the file, enforces the atomic max_lines threshold, writes the new content, and records the fix (id + diff summary) in \`.iterate/fixes/registry.json\`
 - \`iterate_diff\` — show the accumulated diff for a fixed file (vs its original backup) or a per-file summary of all fixes
 - \`iterate_rollback\` — revert a fix by id: restore the file from its backup, remove the fix from the registry, log a \`revert\` entry. Use when a round's validation fails
 - \`iterate_checkpoint\` — save / load / clear an iteration checkpoint (\`.iterate/checkpoint.json\`) so a long run can resume where it left off
 - \`iterate_status\` — summarize the current run: mode, round, fixes applied, architectural remaining, decision-log size, checkpoint presence
+- \`iterate_history\` — inspect the runtime state in detail: decision-log entries and applied fixes (optionally scoped to a round or a fixed file)
+- \`iterate_prune\` — remove stale runtime artifacts (\`.iterate/\` entries). Defaults to a read-only dry-run that reports what WOULD be removed; pass \`dryRun:false\` to actually prune.
 
 ### When to use
 When the user asks to review or iterate on the project (e.g. "review this project", "iterate on error handling", "check the codebase for issues", "dry-run review", "反复审查"), run an iterate **workflow** by calling the \`workflow\` tool.
@@ -176,8 +178,10 @@ for (let r = startRound; r <= maxRounds; r++) {
   rounds.push(thisRound)
 
   // Deterministic dedupe / known_intentional filter / severity sort for this round.
+  // \`fixedCount\` is threaded into the report summary so the client dashboard can
+  // show a running "fixes applied" metric for normal mode.
   const agg = await agent(
-    'Call iterate_review({operation:"aggregate", mode:"normal", rounds:' + JSON.stringify([thisRound]) + ', knownIntentional:' + JSON.stringify(knownIntentional) + '}) and return the report JSON.',
+    'Call iterate_review({operation:"aggregate", mode:"normal", rounds:' + JSON.stringify([thisRound]) + ', knownIntentional:' + JSON.stringify(knownIntentional) + ', fixedCount:' + fixedCount + '}) and return the report JSON.',
     { label: 'review:aggregate:r' + r }
   )
   const findings = (agg && agg.report && agg.report.findings) ? agg.report.findings : thisRound.findings

package/src/tools/decision-log.ts

@@ -8,6 +8,36 @@ import type { DecisionLogEntry } from '../types.ts'
 const LOG_DIR = '.iterate'
 const LOG_FILE = 'decision-log.jsonl'
 
+/** All valid DecisionLogEntry `type` values (must stay in sync with Types). */
+const VALID_ENTRY_TYPES = new Set<DecisionLogEntry['type']>([
+  'round_start',
+  'review_result',
+  'atomic_fix',
+  'architectural_fix',
+  'revert',
+  'round_failed',
+  'validation',
+  'decision',
+  'report',
+])
+
+/**
+ * Validate a candidate (type, round, data) triple for an append operation.
+ * Returns an error string on failure, or null when the entry is well-formed.
+ */
+function validateEntryInput(type: unknown, round: unknown, data: unknown): string | null {
+  if (typeof type !== 'string' || !VALID_ENTRY_TYPES.has(type as DecisionLogEntry['type'])) {
+    return `type must be one of: ${[...VALID_ENTRY_TYPES].join(', ')}.`
+  }
+  if (typeof round !== 'number' || !Number.isInteger(round) || round < 1) {
+    return 'round must be a positive integer.'
+  }
+  if (data !== undefined && data !== null && typeof data !== 'object') {
+    return 'data must be an object (or omitted).'
+  }
+  return null
+}
+
 /**
  * Resolve the log file path, creating the directory if needed.
  */
@@ -81,13 +111,14 @@ export function registerDecisionLogTool(ctx: { tools: { register: (def: ReturnTy
           type: 'string',
           description:
             'Entry type (required for append): round_start, review_result, atomic_fix, ' +
-            'architectural_fix, revert, validation, decision, report.',
+            'architectural_fix, revert, round_failed, validation, decision, report.',
           enum: [
             'round_start',
             'review_result',
             'atomic_fix',
             'architectural_fix',
             'revert',
+            'round_failed',
             'validation',
             'decision',
             'report',
@@ -144,18 +175,24 @@ export function registerDecisionLogTool(ctx: { tools: { register: (def: ReturnTy
         }
 
         if (args.operation === 'append') {
-          if (!args.type || !args.round) {
+          const invalid = validateEntryInput(args.type, args.round, args.data)
+          if (invalid !== null) {
             return {
               operation: 'append',
-              error: 'type and round are required for append operation.',
+              error: invalid,
             }
           }
+          const type = args.type as DecisionLogEntry['type']
+          const round = args.round as number
+          const data = args.data === undefined || args.data === null
+            ? {}
+            : args.data as Record<string, unknown>
 
           const entry: DecisionLogEntry = {
             timestamp: new Date().toISOString(),
-            round: args.round,
-            type: args.type as DecisionLogEntry['type'],
-            data: (args.data as Record<string, unknown>) ?? {},
+            round,
+            type,
+            data,
           }
 
           const result = appendDecisionEntry(projectRoot, entry)

package/src/tools/review.ts

@@ -72,6 +72,12 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
             'For `meta-review`: the ReviewReport JSON (as returned by `aggregate`) to audit for ' +
             'internal consistency and produce the final review report.',
         },
+        fixedCount: {
+          type: 'integer',
+          description:
+            'For `aggregate` (normal mode only): number of atomic fixes applied so far. ' +
+            'Surfaces a running "fixes applied" metric on the report summary.',
+        },
         path: {
           type: 'string',
           description: 'Project root directory (default: current working directory).',
@@ -144,6 +150,7 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
             maxReviewRounds,
             rounds,
             knownIntentional: args.knownIntentional as KnownIntentional[] | undefined,
+            fixedCount: typeof args.fixedCount === 'number' ? args.fixedCount : undefined,
           })
           return { operation: 'aggregate', mode, report: report as unknown as JsonValue }
         }

package/src/types.ts

@@ -34,6 +34,7 @@ export interface DecisionLogEntry {
     | 'validation'
     | 'decision'
     | 'report'
+    | 'round_failed'
   data: Record<string, unknown>
 }
 
@@ -82,6 +83,8 @@ export interface ReviewReport {
     medium: number
     low: number
     byDimension: Record<string, number>
+    /** Number of atomic fixes applied so far (normal mode only; absent in dry-run). */
+    fixedCount?: number
   }
 }