iterate-plugin 3.8.0 → 3.9.1

package/src/file-lock.ts

@@ -133,15 +133,21 @@ export function acquireProjectLockChecked(
       fd = openSync(lockPath, 'wx')
     } catch (err) {
       if ((err as NodeJS.ErrnoException).code !== 'EEXIST') return { acquired: false, release: () => {} }
-      // Lock exists — steal it when the owner is gone or the lock is ancient.
+      // Lock exists — steal it when the owner is VERIFIABLY gone, or when the
+      // lock file is ancient. The stamp is read defensively: a lock is created
+      // empty (`openSync(..., 'wx')`) and the holder's pid lands a moment later,
+      // so an empty/garbled stamp means "just created, holder still writing" —
+      // treating `Number('') === 0` as a dead owner would let a contender steal
+      // a live lock and enter the same critical section. Only a parseable
+      // positive pid that is dead (or an ancient mtime) is stolen.
       let stale = false
       try {
         const st = statSync(lockPath)
-        if (Date.now() - st.mtimeMs > staleMs) stale = true
-        else {
-          const pid = Number(readFileSync(lockPath, 'utf-8'))
-          if (!processAlive(pid)) stale = true
-        }
+        const ancient = Date.now() - st.mtimeMs > staleMs
+        const raw = readFileSync(lockPath, 'utf-8').trim()
+        const pid = /^\d+$/.test(raw) ? Number(raw) : 0
+        if (pid > 0) stale = !processAlive(pid) || ancient
+        else stale = ancient
       } catch {
         stale = true // unreadable/vanishing lock → retry as stale
       }
@@ -265,17 +271,49 @@ export function makeLockRelease(lockPath: string, ino?: number): () => void {
  * Run `fn` while holding the advisory lock named `name`.
  * The release is guaranteed via `finally`; `fn`'s value or error propagates
  * unchanged. Not reentrant for the same (projectRoot, name) — see header.
+ *
+ * `fn` may return a promise: in that case the lock is held until it settles, so
+ * a read-modify-write that spans `await`ed fs calls is actually serialized
+ * (releasing when `fn()` *returns its promise* would defeat the lock entirely).
  */
 export function withProjectLock<T>(
   projectRoot: string,
   name: string,
   fn: () => T,
+  options?: LockOptions,
+): T
+export function withProjectLock<T>(
+  projectRoot: string,
+  name: string,
+  fn: () => Promise<T>,
+  options?: LockOptions,
+): Promise<T>
+export function withProjectLock<T>(
+  projectRoot: string,
+  name: string,
+  fn: () => T | Promise<T>,
   options: LockOptions = {},
-): T {
+): T | Promise<T> {
   const release = acquireProjectLock(projectRoot, name, options)
+  let out: T | Promise<T>
   try {
-    return fn()
-  } finally {
+    out = fn()
+  } catch (err) {
     release()
+    throw err
+  }
+  if (out && typeof (out as Promise<T>).then === 'function') {
+    return (out as Promise<T>).then(
+      (value) => {
+        release()
+        return value
+      },
+      (err) => {
+        release()
+        throw err
+      },
+    )
   }
+  release()
+  return out
 }

package/src/git-scope.ts

@@ -177,21 +177,35 @@ export function runGit(
   opts: { signal?: AbortSignal } = {},
 ): Promise<{ ok: boolean; stdout: string; stderr: string; exitCode: number }> {
   return new Promise((resolve) => {
-    execFile(
-      'git',
-      args,
-      {
-        cwd,
-        timeout: 30_000,
-        maxBuffer: 10 * 1024 * 1024,
-        env: { ...process.env, PAGER: 'cat' },
-        signal: opts.signal,
-      },
-      (error, stdout, stderr) => {
-        const exitCode = error ? (typeof error.code === 'number' ? error.code : 1) : 0
-        resolve({ ok: exitCode === 0, stdout: stdout ?? '', stderr: stderr ?? '', exitCode })
-      },
-    )
+    // execFile can THROW SYNCHRONOUSLY (rather than call back with an error)
+    // when an argument cannot be encoded — e.g. a NUL or lone surrogate in the
+    // config-supplied target branch. Without this guard that throw escapes the
+    // promise executor, rejecting `runGit` and propagating out of the tool call
+    // instead of degrading to the documented full-scope fallback.
+    try {
+      execFile(
+        'git',
+        args,
+        {
+          cwd,
+          timeout: 30_000,
+          maxBuffer: 10 * 1024 * 1024,
+          env: { ...process.env, PAGER: 'cat' },
+          signal: opts.signal,
+        },
+        (error, stdout, stderr) => {
+          const exitCode = error ? (typeof error.code === 'number' ? error.code : 1) : 0
+          resolve({ ok: exitCode === 0, stdout: stdout ?? '', stderr: stderr ?? '', exitCode })
+        },
+      )
+    } catch (err) {
+      resolve({
+        ok: false,
+        stdout: '',
+        stderr: err instanceof Error ? err.message : String(err),
+        exitCode: 1,
+      })
+    }
   })
 }
 

package/src/index.ts

@@ -2,16 +2,18 @@
  * iterate-plugin — dsh plugin for the iterate autonomous closed-loop workflow
  *
  * Architecture:
- * - The plugin registers 17 tools (14 original + 3 v3.0 quality command center tools)
+ * - The plugin registers 18 tools (14 original + 3 v3.0 quality command center
+ *   tools + 1 v3.9 report export)
  *   Original: config, validate, decision-log, context, review, triage, fix, diff,
  *   rollback, checkpoint, status, history, prune, transcript
  *   v3.0: experience, quality_gate, defense_events
+ *   v3.9: report
  * - 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 17 tools to do real work (read config, run validation, log decisions,
+ * - Subagents use the 18 tools to do real work (read config, run validation, log decisions,
  *   review, triage, apply/rollback/fixing, checkpoint, status, history, prune, transcript,
- *   query experience bank, check quality gates, query defense events)
+ *   query experience bank, check quality gates, query defense events, export a report)
  * - A `tools/pre-execute` hook gates destructive iterate calls behind human approval
  *   (F8 observatory approval policy: ask / deny / allow).
  *
@@ -23,7 +25,7 @@
  *
  * Key files:
  * - src/index.ts      — Plugin entry: register tools + inject skill prompt
- * - src/tools/        — 17 tool implementations (14 original + 3 v3.0)
+ * - src/tools/        — 18 tool implementations (14 original + 3 v3.0 + 1 v3.9)
  * - src/config-loader.ts — YAML config loading
  * - src/types.ts     — Shared types
  */
@@ -43,6 +45,7 @@ import { registerTranscriptTool } from './tools/transcript.ts'
 import { registerExperienceBankTool } from './tools/experience-bank.ts'
 import { registerQualityGateTool } from './tools/quality-gate.ts'
 import { registerDefenseEventsTool } from './tools/defense-events.ts'
+import { registerReportTool } from './tools/report.ts'
 import { registerSessionHooks } from './session-hooks.ts'
 import { registerLiveCapture } from './live.ts'
 import { installWorkingDirectoryContext } from './working-directory.ts'
@@ -92,6 +95,8 @@ export function apply(ctx: Context): void {
     ['iterate_experience', () => registerExperienceBankTool(ctx)],
     ['iterate_quality_gate', () => registerQualityGateTool(ctx)],
     ['iterate_defense_events', () => registerDefenseEventsTool(ctx)],
+    // v3.9: PR-ready / CI-ready report export
+    ['iterate_report', () => registerReportTool(ctx)],
   ]
   for (const [toolName, register] of toolRegistrations) {
     try {