iterate-plugin 3.2.1 → 3.3.0

package/lib/parse.js

@@ -557,12 +557,15 @@ export function normalizeTranscript(manifest) {
     : null
 
   const ap = safeGet(src, 'approval')
+  const tm = safeGet(src, 'taskMode')
   return {
     version: asNum(safeGet(src, 'version')),
     project: asStr(safeGet(src, 'project')),
     updatedAt: asStr(safeGet(src, 'updatedAt')),
     active: asBool(safeGet(src, 'active')),
     mode: asStr(safeGet(src, 'mode')) || null,
+    // v3.0: harness task_mode (code/iterate), tolerated when absent.
+    taskMode: tm === 'code' || tm === 'iterate' ? tm : null,
     goal: asStr(safeGet(src, 'goal')),
     phases: asArray(safeGet(src, 'phases')).map((p) => (typeof p === 'string' ? p : '')),
     round: asNum(safeGet(src, 'round')),
@@ -586,6 +589,355 @@ export function normalizeTranscript(manifest) {
   }
 }
 
+// ─── Quality command center session scans (v3.1+) ───────────────────────────
+//
+// The F8/F9/F10 observatory tabs render machine-readable data that the model
+// already surfaces through `iterate_quality_gate` / `iterate_experience` /
+// `iterate_defense_events`. Because the client cannot call harness tools, these
+// scanners recover the LATEST result of each tool from the in-memory session
+// stream (same reverse-chronological strategy as scanSessionForTranscript) and
+// normalize it into a JSON-safe shape for rendering. Every field degrades to a
+// safe default so a partial/malformed result never crashes the slot.
+
+const DEFENSE_EVENT_TYPES = ['precondition_failed', 'rollback', 'invariant_violated', 'assumption_falsified']
+
+/**
+ * Check whether `obj` is a QualityGateSnapshot as produced by quality-store.ts.
+ * Requires the three gate discriminators (overallStatus + overallScore +
+ * dimensions array) so unrelated `{ snapshot: ... }` shapes never collide.
+ *
+ * @param {unknown} obj
+ * @returns {boolean}
+ */
+export function isQualityGateSnapshot(obj) {
+  if (!obj || typeof obj !== 'object') return false
+  const o = /** @type {Record<string, unknown>} */ (obj)
+  const status = safeGet(o, 'overallStatus')
+  return (
+    (status === 'pass' || status === 'fail' || status === 'pending') &&
+    typeof safeGet(o, 'overallScore') === 'number' &&
+    Array.isArray(safeGet(o, 'dimensions'))
+  )
+}
+
+/**
+ * Check whether `obj` is an `iterate_experience` result node. `list`/`search`
+ * carry an `entries` array; `get`/`add` carry a single `entry` object. Either
+ * shape is enough to render the F9 experience bank.
+ *
+ * @param {unknown} obj
+ * @returns {boolean}
+ */
+export function isExperienceBankResult(obj) {
+  if (!obj || typeof obj !== 'object') return false
+  const o = /** @type {Record<string, unknown>} */ (obj)
+  const entry = safeGet(o, 'entry')
+  return (
+    (Array.isArray(safeGet(o, 'entries')) && typeof safeGet(o, 'count') === 'number') ||
+    (!!entry && typeof entry === 'object' && typeof safeGet(o, 'operation') === 'string')
+  )
+}
+
+/**
+ * Check whether `obj` is an `iterate_defense_events` result node. `list` carries
+ * an `events` array, `counts` / `record` carry a `counts` map. Either shape is
+ * enough to render the F10 defense event stream.
+ *
+ * @param {unknown} obj
+ * @returns {boolean}
+ */
+export function isDefenseEventsResult(obj) {
+  if (!obj || typeof obj !== 'object') return false
+  const o = /** @type {Record<string, unknown>} */ (obj)
+  const counts = safeGet(o, 'counts')
+  return (
+    (Array.isArray(safeGet(o, 'events')) && typeof safeGet(o, 'count') === 'number') ||
+    (!!counts && typeof counts === 'object' && typeof safeGet(o, 'operation') === 'string')
+  )
+}
+
+/**
+ * Shared deep-find: first node in `obj` (circular + depth guarded) satisfying a
+ * predicate, with the same traversal semantics as findReportInObject.
+ *
+ * @param {unknown} obj
+ * @param {(o: Record<string, unknown>) => boolean} predicate
+ * @param {Set<unknown>} [seen]
+ * @param {number} [maxDepth=20]
+ * @returns {Record<string, unknown> | null}
+ */
+function findFirstInObject(obj, predicate, seen, maxDepth = 20) {
+  if (maxDepth <= 0) return null
+  if (!obj || typeof obj !== 'object') return null
+
+  const s = seen || new Set()
+  if (s.has(obj)) return null
+  s.add(obj)
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const found = findFirstInObject(item, predicate, s, maxDepth - 1)
+      if (found) return found
+    }
+    return null
+  }
+
+  if (typeof obj === 'object') {
+    const o = /** @type {Record<string, unknown>} */ (obj)
+    if (predicate(o)) return o
+    for (const key of safeKeys(o)) {
+      const val = safeGet(o, key)
+      if (val && typeof val === 'object') {
+        const found = findFirstInObject(val, predicate, s, maxDepth - 1)
+        if (found) return found
+      }
+    }
+  }
+  return null
+}
+
+/** Deep-find the first QualityGateSnapshot inside `obj`. */
+function findQualityGateInObject(obj) {
+  return findFirstInObject(obj, (o) => isQualityGateSnapshot(o))
+}
+
+/** Deep-find the first `iterate_experience` result node inside `obj`. */
+function findExperienceResultInObject(obj) {
+  return findFirstInObject(obj, (o) => isExperienceBankResult(o))
+}
+
+/** Deep-find the first `iterate_defense_events` result node inside `obj`. */
+function findDefenseResultInObject(obj) {
+  return findFirstInObject(obj, (o) => isDefenseEventsResult(o))
+}
+
+/**
+ * Return the raw result/message node of the most recent execution of `toolName`
+ * in a session snapshot. Scans `session.toolCalls` (reverse chronological,
+ * matching the harness's in-memory stream shape) and falls back to
+ * `session.messages[].content` (assistant tool-call blocks). Returns the raw
+ * node (object or string) or null.
+ *
+ * @param {unknown} session
+ * @param {string} toolName
+ * @returns {unknown}
+ */
+function latestToolResultNode(session, toolName) {
+  if (!session || typeof session !== 'object') return null
+
+  const s = /** @type {Record<string, unknown>} */ (session)
+
+  const toolCalls = safeGet(s, 'toolCalls')
+  if (Array.isArray(toolCalls)) {
+    const calls = /** @type {Array<Record<string, unknown>>} */ (toolCalls)
+    for (let i = calls.length - 1; i >= 0; i--) {
+      const call = calls[i]
+      if (!call) continue
+      const tool = String(safeGet(call, 'tool') ?? '')
+      if (tool !== toolName && !tool.endsWith(toolName)) continue
+      const result = safeGet(call, 'result')
+      if (result !== undefined && result !== null) return result
+      const message = safeGet(call, 'message')
+      if (message !== undefined && message !== null) return message
+    }
+  }
+
+  const messages = safeGet(s, 'messages')
+  if (Array.isArray(messages)) {
+    const msgs = /** @type {Array<Record<string, unknown>>} */ (messages)
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const msg = msgs[i]
+      if (!msg) continue
+      const content = safeGet(msg, 'content')
+      if (content !== undefined && content !== null) return content
+    }
+  }
+
+  return null
+}
+
+/**
+ * Normalize a QualityGateSnapshot into a JSON-safe object (see
+ * normalizeTranscript for the defensive style contract).
+ *
+ * @param {Record<string, unknown> | null | undefined} raw
+ * @returns {Record<string, unknown>}
+ */
+export function normalizeQualityGateSnapshot(raw) {
+  const src = raw && typeof raw === 'object'
+    ? /** @type {Record<string, unknown>} */ (raw)
+    : {}
+  const asNum = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
+  const asStr = (v) => (typeof v === 'string' ? v : '')
+  const status = safeGet(src, 'overallStatus')
+  const dims = Array.isArray(safeGet(src, 'dimensions')) ? safeGet(src, 'dimensions') : []
+  return {
+    timestamp: asStr(safeGet(src, 'timestamp')),
+    overallStatus: status === 'pass' || status === 'fail' || status === 'pending' ? status : 'pending',
+    overallScore: asNum(safeGet(src, 'overallScore')),
+    verificationPassRate: asNum(safeGet(src, 'verificationPassRate')),
+    totalChecks: asNum(safeGet(src, 'totalChecks')),
+    passedChecks: asNum(safeGet(src, 'passedChecks')),
+    failedChecks: asNum(safeGet(src, 'failedChecks')),
+    failReason: asStr(safeGet(src, 'failReason')) || null,
+    totalFindings: asNum(safeGet(src, 'totalFindings')),
+    criticalCount: asNum(safeGet(src, 'criticalCount')),
+    highCount: asNum(safeGet(src, 'highCount')),
+    mediumCount: asNum(safeGet(src, 'mediumCount')),
+    lowCount: asNum(safeGet(src, 'lowCount')),
+    dimensions: (/** @type {unknown[]} */ (dims)).map((d) => {
+      const rec = /** @type {Record<string, unknown>} */ (d && typeof d === 'object' ? d : {})
+      const dimStatus = safeGet(rec, 'status')
+      return {
+        dimension: asStr(safeGet(rec, 'dimension')),
+        convergenceRate: asNum(safeGet(rec, 'convergenceRate')),
+        findingsCount: asNum(safeGet(rec, 'findingsCount')),
+        fixedCount: asNum(safeGet(rec, 'fixedCount')),
+        score: asNum(safeGet(rec, 'score')),
+        status: dimStatus === 'pass' || dimStatus === 'warn' || dimStatus === 'fail' ? dimStatus : 'warn',
+      }
+    }),
+  }
+}
+
+/**
+ * Scan a session snapshot for the latest `iterate_quality_gate` result and
+ * return its normalized QualityGateSnapshot (or null).
+ *
+ * @param {unknown} session
+ * @returns {Record<string, unknown> | null}
+ */
+export function scanSessionForQualityGate(session) {
+  const node = latestToolResultNode(session, 'iterate_quality_gate')
+  if (node === null) return null
+  const found = findQualityGateInObject(node)
+  if (!found) return null
+  return normalizeQualityGateSnapshot(found)
+}
+
+/**
+ * Normalize an `iterate_experience` result node into a JSON-safe object.
+ * `get`/`add` results (single `entry`) are folded into the `entries` array so
+ * the F9 panel has one rendering path regardless of operation.
+ *
+ * @param {Record<string, unknown> | null | undefined} raw
+ * @returns {Record<string, unknown>}
+ */
+export function normalizeExperienceBankResult(raw) {
+  const src = raw && typeof raw === 'object'
+    ? /** @type {Record<string, unknown>} */ (raw)
+    : {}
+  const asNum = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
+  const asStr = (v) => (typeof v === 'string' ? v : '')
+  const asArr = (v) => (Array.isArray(v) ? /** @type {unknown[]} */ (v) : [])
+  const entry = safeGet(src, 'entry')
+  const rawEntries = Array.isArray(safeGet(src, 'entries'))
+    ? /** @type {unknown[]} */ (safeGet(src, 'entries'))
+    : (entry && typeof entry === 'object' ? [entry] : [])
+  return {
+    operation: asStr(safeGet(src, 'operation')),
+    count: asNum(safeGet(src, 'count')),
+    totalHits: asNum(safeGet(src, 'totalHits')),
+    added: safeGet(src, 'added') === true,
+    entries: rawEntries.map((e) => {
+      const rec = /** @type {Record<string, unknown>} */ (e && typeof e === 'object' ? e : {})
+      return {
+        id: asStr(safeGet(rec, 'id')),
+        timestamp: asStr(safeGet(rec, 'timestamp')),
+        dimension: asStr(safeGet(rec, 'dimension')),
+        pattern: asStr(safeGet(rec, 'pattern')),
+        description: asStr(safeGet(rec, 'description')),
+        verifiedFix: asStr(safeGet(rec, 'verifiedFix')),
+        findingSummary: asStr(safeGet(rec, 'findingSummary')),
+        severity: asStr(safeGet(rec, 'severity')),
+        hitCount: asNum(safeGet(rec, 'hitCount')),
+        lastHitAt: asStr(safeGet(rec, 'lastHitAt')) || null,
+        files: asArr(safeGet(rec, 'files')).map((f) => (typeof f === 'string' ? f : '')),
+        tags: asArr(safeGet(rec, 'tags')).map((t) => (typeof t === 'string' ? t : '')),
+      }
+    }),
+  }
+}
+
+/**
+ * Scan a session snapshot for the latest `iterate_experience` result and return
+ * its normalized values (or null when the session has none).
+ *
+ * @param {unknown} session
+ * @returns {Record<string, unknown> | null}
+ */
+export function scanSessionForExperienceBank(session) {
+  const node = latestToolResultNode(session, 'iterate_experience')
+  if (node === null) return null
+  const found = findExperienceResultInObject(node)
+  if (!found) return null
+  return normalizeExperienceBankResult(found)
+}
+
+/**
+ * Normalize an `iterate_defense_events` result node into a JSON-safe object.
+ * `record` results (single `event` + `counts`) fold into the same shape as
+ * `list`/`counts` so the F10 panel has one rendering path.
+ *
+ * @param {Record<string, unknown> | null | undefined} raw
+ * @returns {Record<string, unknown>}
+ */
+export function normalizeDefenseEventsResult(raw) {
+  const src = raw && typeof raw === 'object'
+    ? /** @type {Record<string, unknown>} */ (raw)
+    : {}
+  const asNum = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
+  const asStr = (v) => (typeof v === 'string' ? v : '')
+  const countsRaw = safeGet(src, 'counts') && typeof safeGet(src, 'counts') === 'object'
+    ? /** @type {Record<string, unknown>} */ (safeGet(src, 'counts'))
+    : {}
+  const counts = /** @type {Record<string, number>} */ ({})
+  for (const type of DEFENSE_EVENT_TYPES) {
+    const n = safeGet(countsRaw, type)
+    counts[type] = typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : 0
+  }
+  const event = safeGet(src, 'event')
+  const rawEvents = Array.isArray(safeGet(src, 'events'))
+    ? /** @type {unknown[]} */ (safeGet(src, 'events'))
+    : (event && typeof event === 'object' ? [event] : [])
+  return {
+    operation: asStr(safeGet(src, 'operation')),
+    count: asNum(safeGet(src, 'count')),
+    language: asStr(safeGet(src, 'language')),
+    counts,
+    events: rawEvents.map((e) => {
+      const rec = /** @type {Record<string, unknown>} */ (e && typeof e === 'object' ? e : {})
+      return {
+        id: asStr(safeGet(rec, 'id')),
+        timestamp: asStr(safeGet(rec, 'timestamp')),
+        round: asNum(safeGet(rec, 'round')),
+        type: asStr(safeGet(rec, 'type')),
+        description: asStr(safeGet(rec, 'description')),
+        defense: asStr(safeGet(rec, 'defense')),
+        outcome: asStr(safeGet(rec, 'outcome')),
+        file: asStr(safeGet(rec, 'file')) || null,
+        line: asNum(safeGet(rec, 'line')) || null,
+        severity: asStr(safeGet(rec, 'severity')),
+      }
+    }),
+  }
+}
+
+/**
+ * Scan a session snapshot for the latest `iterate_defense_events` result and
+ * return its normalized values (or null when the session has none).
+ *
+ * @param {unknown} session
+ * @returns {Record<string, unknown> | null}
+ */
+export function scanSessionForDefenseEvents(session) {
+  const node = latestToolResultNode(session, 'iterate_defense_events')
+  if (node === null) return null
+  const found = findDefenseResultInObject(node)
+  if (!found) return null
+  return normalizeDefenseEventsResult(found)
+}
+
 // ─── Run-summary / meta-review verdict detection ─────────────────────────────
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iterate-plugin",
-  "version": "3.2.1",
-  "description": "dsh plugin that turns the iterate skill into an autonomous closed-loop harness with quality command center and experience bank (v3.2). Features: plan -> parallel review xN -> atomic fixes -> validate -> loop -> auto-stop, plus dry-run pure-review mode, quality gate compute/persist, writable experience bank, defense events stream (record + bilingual labels), and native command buttons.",
+  "version": "3.3.0",
+  "description": "dsh plugin that turns the iterate skill into an autonomous closed-loop harness with quality command center and experience bank (v3.3). Features: plan -> parallel review xN -> atomic fixes -> validate -> loop -> auto-stop, plus dry-run pure-review mode, quality gate compute/persist, writable experience bank, defense events stream (record + bilingual labels), and native command buttons — with a live quality command center (F8/F9/F10 render real session data), §8 assign-fix instruction, and task_mode indicator wired end to end.",
   "type": "module",
   "license": "MIT",
   "repository": {

package/src/approval-gate.ts

@@ -102,30 +102,4 @@ export function decideApproval(
 /** True when any destructive iterate tool is listed in a name set. */
 export function isDestructiveIterateTool(name: unknown): boolean {
   return typeof name === 'string' && DESTRUCTIVE_TOOLS.has(name)
-}
-
-/** Tool-facing gate result: run, or refuse (with an explicit human-approval signal). */
-export type ToolGateResult =
-  | { ok: true }
-  | { ok: false; requiresApproval: true; reason: string }
-  | { ok: false; error: string }
-
-/**
- * Evaluate an iterate tool's own boundary gate for a destructive call.
- * `approvedArg` is the caller-supplied `approved: true` flag (human consent
- * already obtained). Returns a run / refuse result without any I/O.
- */
-export function toolGate(
-  policy: 'ask' | 'deny' | 'allow',
-  execution: ToolExecutionLike,
-  approvedArg?: unknown,
-): ToolGateResult {
-  const decision = decideApproval(execution, policy)
-  if (decision.kind === 'allow') return { ok: true }
-  if (decision.kind === 'deny') {
-    return { ok: false, error: `Blocked by observatory approval policy: ${decision.reason}` }
-  }
-  // ask
-  if (approvedArg === true) return { ok: true }
-  return { ok: false, requiresApproval: true, reason: decision.reason }
 }