@naxodev/apnea 0.1.0 → 0.2.1

package/extension/domain/verify-commands.ts

@@ -1,128 +1,220 @@
-/** Does this line end in an ODD run of backslashes — a shell continuation? */
-function endsInContinuation(line: string): boolean {
-  const run = /(\\+)$/.exec(line)
-  return run !== null && run[1]!.length % 2 === 1
+export type VerifyBlock = {
+  readonly interpreter: "bash" | "sh"
+  readonly source: string
 }
 
-/**
- * Split fence lines into logical shell commands: continuations joined,
- * comments dropped — in ONE pass, because the two interact and both split
- * orderings shipped bugs.
- *
- * Join-then-strip (version 1): a comment ending in `\` swallowed the command
- * below it, then the merged line was dropped as a comment — `bun test
- * extension` silently never ran and the phase committed green.
- *
- * Strip-then-join (version 2): removing a comment line that sat BETWEEN a
- * continued line and the next command spliced the two commands together —
- * `test -f README.md \` + `# note` + `bun test extension` became one command.
- *
- * bash resolves this by interleaving, and each command later runs through
- * `bash -lc`, so bash's rules are the spec:
- *
- * - Joining appends the next line with NOTHING between; the final backslash of
- *   an odd run is dropped, the rest stay (they are escaped literals). A
- *   backslash that is not the line's last character continues nothing —
- *   `echo hi \ ` escapes the space and ends the command.
- * - A `#` at the start of a logical command is a comment; its own trailing
- *   backslash is inside the comment and continues nothing.
- * - A comment line reached MID-continuation ends the logical command, when the
- *   `#` would start a word in the joined text (whitespace before it). Without
- *   whitespace on either side of the join, `over\` + `#note` is the single
- *   word `over#note`, not a comment — so it is appended, not terminated on.
- */
-function logicalCommands(lines: string[]): string[] {
-  const out: string[] = []
-  let acc = ""
-  let pending = false
-  for (const line of lines) {
-    const isCommentish = line.trim().startsWith("#")
-    if (!pending && isCommentish) continue
-    if (pending && isCommentish && (/\s$/.test(acc) || /^\s/.test(line))) {
-      out.push(acc)
-      acc = ""
-      pending = false
-      continue
-    }
-    const continues = endsInContinuation(line)
-    const text = continues ? line.slice(0, -1) : line
-    acc = pending ? acc + text : text
-    pending = continues
-    if (!pending) {
-      out.push(acc)
-      acc = ""
-    }
-  }
-  // A dangling continuation on the last line: keep what we have rather than
-  // dropping the command on the floor.
-  if (pending) out.push(acc)
-  return out
+type FenceRegion = {
+  readonly start: number
+  readonly bodyStart: number
+  readonly bodyEnd: number
+  readonly info: string
+  readonly indent: number
+}
+
+type Heading = {
+  readonly start: number
+  readonly end: number
+  readonly rank: number | null
+  readonly text: string
+}
+
+export function normalizeVerifySource(source: string): string {
+  return source.replace(/\r\n?/g, "\n")
 }
 
-function toCommands(lines: string[]): string[] {
-  const cmds: string[] = []
-  for (const joined of logicalCommands(lines)) {
-    const t = joined.trim()
-    if (t) cmds.push(t)
+function atxHeading(line: string): { rank: number; text: string } | null {
+  const match = /^ {0,3}(#{1,6})(?:[\t ]+(.*?)|[\t ]*)$/.exec(line)
+  if (!match) return null
+  return {
+    rank: match[1]!.length,
+    text: (match[2] ?? "").replace(/[\t ]+#+[\t ]*$/, "").trim(),
   }
-  return cmds
 }
 
-function commandsFromFenceBody(body: string): string[] {
-  return toCommands(body.split(/\r?\n/))
+function boldHeading(line: string): string | null {
+  return /^ {0,3}\*\*(.+?)\*\*[\t ]*$/.exec(line)?.[1]?.trim() ?? null
 }
 
-/**
- * Extract shell commands from a phase package.
- * Prefer the fence under a "Verify commands" heading — packages often embed
- * earlier ```bash sketches that must not be executed at the commit gate.
- */
-export function extractVerifyCommands(phasePackageText: string): string[] {
-  // Heading-scoped fence first (## / ### / **Verify commands**)
-  const section = phasePackageText.match(
-    /(?:^|\n)(?:#{1,6}\s*|\*\*)Verify commands(?:\*\*)?\s*\r?\n([\s\S]*?)(?=\n#{1,6}\s|\n\*\*[A-Z]|$)/i,
-  )
-  if (section) {
-    const fence = section[1]!.match(/```(?:sh|bash|shell)\r?\n([\s\S]*?)```/i)
-    if (fence) {
-      const cmds = commandsFromFenceBody(fence[1]!)
-      if (cmds.length) return cmds
+function scanMarkdown(text: string): {
+  fences: FenceRegion[]
+  headings: Heading[]
+  unclosedFence: boolean
+} {
+  const fences: FenceRegion[] = []
+  const headings: Heading[] = []
+  let open:
+    | {
+        marker: "`" | "~"
+        length: number
+        start: number
+        bodyStart: number
+        info: string
+        indent: number
+      }
+    | undefined
+
+  let offset = 0
+  while (offset < text.length) {
+    const newline = text.indexOf("\n", offset)
+    const lineEnd = newline === -1 ? text.length : newline
+    const next = newline === -1 ? text.length : newline + 1
+    const line = text.slice(offset, lineEnd)
+
+    if (open) {
+      const closing = /^ {0,3}(`{3,}|~{3,})[\t ]*$/.exec(line)?.[1]
+      if (closing?.[0] === open.marker && closing.length >= open.length) {
+        fences.push({
+          start: open.start,
+          bodyStart: open.bodyStart,
+          bodyEnd: offset,
+          info: open.info,
+          indent: open.indent,
+        })
+        open = undefined
+      }
+    } else {
+      const opening = /^( {0,3})(`{3,}|~{3,})(.*)$/.exec(line)
+      const marker = opening?.[2]
+      const info = opening?.[3] ?? ""
+      if (marker && !(marker[0] === "`" && info.includes("`"))) {
+        open = {
+          marker: marker[0] as "`" | "~",
+          length: marker.length,
+          start: offset,
+          bodyStart: next,
+          info: info.trim(),
+          indent: opening[1]!.length,
+        }
+      } else {
+        const atx = atxHeading(line)
+        const bold = boldHeading(line)
+        if (atx) {
+          headings.push({
+            start: offset,
+            end: next,
+            rank: atx.rank,
+            text: atx.text,
+          })
+        } else if (bold !== null) {
+          headings.push({ start: offset, end: next, rank: null, text: bold })
+        }
+      }
     }
+
+    offset = next
   }
 
-  // Fallback: last sh/bash fence in the doc (verify blocks are usually last)
-  const all = [
-    ...phasePackageText.matchAll(/```(?:sh|bash|shell)\r?\n([\s\S]*?)```/gi),
-  ]
-  for (let i = all.length - 1; i >= 0; i--) {
-    const cmds = commandsFromFenceBody(all[i]![1]!)
-    if (cmds.length) return cmds
+  return { fences, headings, unclosedFence: open !== undefined }
+}
+
+function toVerifyBlock(text: string, fence: FenceRegion): VerifyBlock | null {
+  const language = fence.info.toLowerCase()
+  if (language !== "bash" && language !== "sh" && language !== "shell") {
+    return null
+  }
+
+  const body = text.slice(fence.bodyStart, fence.bodyEnd)
+  const source =
+    fence.indent === 0
+      ? body
+      : body.replace(new RegExp(`^ {0,${fence.indent}}`, "gm"), "")
+  const hasExecutableLine = source
+    .split("\n")
+    .some((line) => line.trim() !== "" && !line.trimStart().startsWith("#"))
+  if (!hasExecutableLine) return null
+
+  return {
+    interpreter: language === "sh" ? "sh" : "bash",
+    source,
   }
+}
 
-  // Last resort: $ / test / bun lines scattered through prose.
-  //
-  // Continuations join FORWARD FROM A MATCHED COMMAND LINE only, never
-  // document-wide. This text is markdown, not shell, and a trailing backslash
-  // on a prose line is a markdown hard break: joining globally glued prose
-  // onto the command below it, the merged line no longer matched the command
-  // pattern, and the check was silently dropped — the gate ran a subset of
-  // the verify commands and committed the phase green. Comments need no
-  // handling here: a line starting with `#` cannot match the pattern.
-  const cmds: string[] = []
-  const rawLines = phasePackageText.split(/\r?\n/)
+function isShellFence(fence: FenceRegion): boolean {
+  return /^(?:bash|sh|shell)$/i.test(fence.info)
+}
+
+/** Does this line end in an odd run of backslashes? */
+function endsInContinuation(line: string): boolean {
+  const run = /(\\+)$/.exec(line)
+  return run !== null && run[1]!.length % 2 === 1
+}
+
+function extractLegacyBlocks(text: string): VerifyBlock[] {
+  const blocks: VerifyBlock[] = []
+  const rawLines = text.split("\n")
   for (let i = 0; i < rawLines.length; i++) {
-    const m = rawLines[i]!.match(
+    const match = rawLines[i]!.match(
       /^\s*(?:\$\s+)?((?:test |node |npm |bun |bunx |chmod |head ).+)$/,
     )
-    if (!m) continue
-    let cmd = m[1]!
-    while (endsInContinuation(cmd) && i + 1 < rawLines.length) {
-      cmd = cmd.slice(0, -1) + rawLines[++i]!
+    if (!match) continue
+    let source = match[1]!
+    while (endsInContinuation(source) && i + 1 < rawLines.length) {
+      source = source.slice(0, -1) + rawLines[++i]!
     }
-    // Dangling continuation on the final line: drop the backslash rather
-    // than handing the shell a command that continues into nothing.
-    if (endsInContinuation(cmd)) cmd = cmd.slice(0, -1)
-    cmds.push(cmd.trim())
+    if (endsInContinuation(source)) source = source.slice(0, -1)
+    blocks.push({ interpreter: "bash", source: source.trim() })
   }
-  return cmds
+  return blocks
+}
+
+/**
+ * Extract interpreter-aware verification scripts from a phase package.
+ * A Verify commands section owns every shell fence below it. Without that
+ * section, only the last shell fence is verification, matching legacy package
+ * selection without splitting a script into unrelated command lines.
+ */
+export function extractVerifyBlocks(phasePackageText: string): VerifyBlock[] {
+  const text = normalizeVerifySource(phasePackageText)
+  const { fences, headings, unclosedFence } = scanMarkdown(text)
+  if (unclosedFence) return []
+  const verifyHeading = headings.find(
+    (heading) => heading.text.toLowerCase() === "verify commands",
+  )
+
+  if (verifyHeading) {
+    const nextHeading = headings.find(
+      (heading) =>
+        heading.start >= verifyHeading.end &&
+        (heading.rank === null ||
+          verifyHeading.rank === null ||
+          (heading.rank !== null && heading.rank <= verifyHeading.rank)),
+    )
+    const sectionEnd = nextHeading?.start ?? text.length
+    const sectionFences = fences.filter(
+      (fence) => fence.start >= verifyHeading.end && fence.start < sectionEnd,
+    )
+    const blocks = sectionFences
+      .filter(isShellFence)
+      .map((fence) => toVerifyBlock(text, fence))
+      .filter((block): block is VerifyBlock => block !== null)
+    return sectionFences.length > 0
+      ? blocks
+      : extractLegacyBlocks(text.slice(verifyHeading.end, sectionEnd))
+  }
+
+  const shellFences = fences.filter(isShellFence)
+  if (shellFences.length > 0) {
+    const block = toVerifyBlock(text, shellFences[shellFences.length - 1]!)
+    return block ? [block] : []
+  }
+
+  return fences.length === 0 ? extractLegacyBlocks(text) : []
+}
+
+/** Render a block for readable logs without leaking its temp path. */
+export function formatVerifyBlock(block: VerifyBlock): string {
+  const source = normalizeVerifySource(block.source)
+  const body = source.endsWith("\n") ? source.slice(0, -1) : source
+  const displayedSource = body
+    .split("\n")
+    .map((line) => `| ${line}`)
+    .join("\n")
+  return `${block.interpreter} -e [verification block]\n${displayedSource}`
+}
+
+/** Render a verification block as a runnable command without its temp path. */
+export function formatVerifyCommand(block: VerifyBlock): string {
+  const source = normalizeVerifySource(block.source)
+  const quotedSource = `'${source.replaceAll("'", `'"'"'`)}'`
+  return `${block.interpreter} -e -c ${quotedSource}`
 }

package/extension/errors.ts

@@ -2,13 +2,13 @@ import { Schema } from "effect"
 import { err, type ToolErr } from "./result.ts"
 
 /** No `.apnea/state.json` for the current project root. */
-export class NoRunState extends Schema.TaggedErrorClass<NoRunState>()(
+export class NoRunState extends Schema.TaggedError<NoRunState>()(
   "NoRunState",
   {},
 ) {}
 
 /** Tool call refused by the step → legal-tools table. */
-export class IllegalTool extends Schema.TaggedErrorClass<IllegalTool>()(
+export class IllegalTool extends Schema.TaggedError<IllegalTool>()(
   "IllegalTool",
   {
     step: Schema.String,
@@ -18,7 +18,7 @@ export class IllegalTool extends Schema.TaggedErrorClass<IllegalTool>()(
 ) {}
 
 /** Dispatch kind refused at the current step. */
-export class IllegalKind extends Schema.TaggedErrorClass<IllegalKind>()(
+export class IllegalKind extends Schema.TaggedError<IllegalKind>()(
   "IllegalKind",
   {
     step: Schema.String,
@@ -28,7 +28,7 @@ export class IllegalKind extends Schema.TaggedErrorClass<IllegalKind>()(
 ) {}
 
 /** Global or project config missing, invalid, or untrusted. */
-export class ConfigError extends Schema.TaggedErrorClass<ConfigError>()(
+export class ConfigError extends Schema.TaggedError<ConfigError>()(
   "ConfigError",
   {
     message: Schema.String,
@@ -38,7 +38,7 @@ export class ConfigError extends Schema.TaggedErrorClass<ConfigError>()(
 ) {}
 
 /** `state.json` present but not decodable / inconsistent. */
-export class StateCorrupt extends Schema.TaggedErrorClass<StateCorrupt>()(
+export class StateCorrupt extends Schema.TaggedError<StateCorrupt>()(
   "StateCorrupt",
   {
     path: Schema.String,
@@ -47,23 +47,32 @@ export class StateCorrupt extends Schema.TaggedErrorClass<StateCorrupt>()(
 ) {}
 
 /** VCS detect / dirty / commit / bookmark failure. */
-export class VcsError extends Schema.TaggedErrorClass<VcsError>()("VcsError", {
+export class VcsError extends Schema.TaggedError<VcsError>()("VcsError", {
   message: Schema.String,
   command: Schema.optional(Schema.String),
 }) {}
 
-/** Herdr CLI / pane / floating failure. */
-export class HerdrError extends Schema.TaggedErrorClass<HerdrError>()(
-  "HerdrError",
+/** Another live Apnea process owns the repository mutation lock. */
+export class OperationLocked extends Schema.TaggedError<OperationLocked>()(
+  "OperationLocked",
   {
     message: Schema.String,
-    command: Schema.optional(Schema.String),
-    details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    repository: Schema.String,
+    lock_path: Schema.String,
+    reason: Schema.String,
+    pid: Schema.Number,
   },
 ) {}
 
+/** Herdr CLI or pane failure. */
+export class HerdrError extends Schema.TaggedError<HerdrError>()("HerdrError", {
+  message: Schema.String,
+  command: Schema.optional(Schema.String),
+  details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {}
+
 /** Commit/review gate refused (e.g. verdict not APPROVED). */
-export class GateRefused extends Schema.TaggedErrorClass<GateRefused>()(
+export class GateRefused extends Schema.TaggedError<GateRefused>()(
   "GateRefused",
   {
     gate: Schema.String,
@@ -73,7 +82,7 @@ export class GateRefused extends Schema.TaggedErrorClass<GateRefused>()(
 ) {}
 
 /** `workflow_wait` hit its timeout without a complete artifact. */
-export class WaitTimeout extends Schema.TaggedErrorClass<WaitTimeout>()(
+export class WaitTimeout extends Schema.TaggedError<WaitTimeout>()(
   "WaitTimeout",
   {
     artifact: Schema.String,
@@ -83,7 +92,7 @@ export class WaitTimeout extends Schema.TaggedErrorClass<WaitTimeout>()(
 ) {}
 
 /** `workflow_wait` aborted (Esc / cancel signal). */
-export class WaitAborted extends Schema.TaggedErrorClass<WaitAborted>()(
+export class WaitAborted extends Schema.TaggedError<WaitAborted>()(
   "WaitAborted",
   {
     artifact: Schema.String,
@@ -91,8 +100,17 @@ export class WaitAborted extends Schema.TaggedErrorClass<WaitAborted>()(
   },
 ) {}
 
+/** A non-wait operation was interrupted by its host cancellation signal. */
+export class OperationAborted extends Schema.TaggedError<OperationAborted>()(
+  "OperationAborted",
+  {
+    operation: Schema.String,
+    details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  },
+) {}
+
 /** Artifact exists but front-matter / shape is invalid. */
-export class ArtifactInvalid extends Schema.TaggedErrorClass<ArtifactInvalid>()(
+export class ArtifactInvalid extends Schema.TaggedError<ArtifactInvalid>()(
   "ArtifactInvalid",
   {
     artifact: Schema.String,
@@ -101,7 +119,7 @@ export class ArtifactInvalid extends Schema.TaggedErrorClass<ArtifactInvalid>()(
 ) {}
 
 /** Phase-package verify commands failed — commit refused. */
-export class VerifyFailed extends Schema.TaggedErrorClass<VerifyFailed>()(
+export class VerifyFailed extends Schema.TaggedError<VerifyFailed>()(
   "VerifyFailed",
   {
     commands: Schema.Array(Schema.String),
@@ -119,10 +137,12 @@ export type AppError =
   | ConfigError
   | StateCorrupt
   | VcsError
+  | OperationLocked
   | HerdrError
   | GateRefused
   | WaitTimeout
   | WaitAborted
+  | OperationAborted
   | ArtifactInvalid
   | VerifyFailed
 
@@ -133,10 +153,12 @@ const APP_ERROR_TAG_LIST = [
   "ConfigError",
   "StateCorrupt",
   "VcsError",
+  "OperationLocked",
   "HerdrError",
   "GateRefused",
   "WaitTimeout",
   "WaitAborted",
+  "OperationAborted",
   "ArtifactInvalid",
   "VerifyFailed",
 ] as const satisfies readonly AppError["_tag"][]
@@ -204,6 +226,15 @@ export function toToolResult(e: AppError): ToolErr {
       return err(e.message, {
         data: e.command !== undefined ? { command: e.command } : undefined,
       })
+    case "OperationLocked":
+      return err(e.message, {
+        data: {
+          repository: e.repository,
+          lock_path: e.lock_path,
+          reason: e.reason,
+          pid: e.pid,
+        },
+      })
     case "HerdrError":
       return err(e.message, {
         data:
@@ -233,6 +264,10 @@ export function toToolResult(e: AppError): ToolErr {
       return err("workflow_wait aborted (Esc / cancel)", {
         data: { artifact: e.artifact, ...(e.details ?? {}) },
       })
+    case "OperationAborted":
+      return err(`${e.operation} aborted (signal / cancel)`, {
+        data: { operation: e.operation, ...(e.details ?? {}) },
+      })
     case "ArtifactInvalid":
       return err(e.message, { data: { artifact: e.artifact } })
     case "VerifyFailed":

package/extension/operation-hooks.ts

@@ -0,0 +1,6 @@
+export type OperationHooks = {
+  readonly signal?: AbortSignal
+  readonly onUpdate?: (partial: {
+    content: Array<{ type: "text"; text: string }>
+  }) => void
+}

package/extension/registry.ts

@@ -18,8 +18,8 @@ import {
   MAX_AUTO_POLL_MS,
   MIN_POLL_MS,
   type WaitParams,
-  type WaitHooks,
 } from "./workflows/wait.ts"
+import type { OperationHooks } from "./operation-hooks.ts"
 
 export type Operation = {
   /** Pi tool name, or null when the operation is not model-facing. */
@@ -46,14 +46,14 @@ export type Operation = {
 type RegisteredOperation = Operation & {
   readonly run: (
     params: Record<string, unknown>,
-    hooks?: WaitHooks,
+    hooks?: OperationHooks,
   ) => Promise<ToolResult>
 }
 
 export type ExecuteOperation = (
   verb: string,
   params: Record<string, unknown>,
-  hooks?: WaitHooks,
+  hooks?: OperationHooks,
 ) => Promise<ToolResult>
 
 // Sourced from domain/state-machine.ts (not hardcoded here) so a new kind
@@ -86,8 +86,8 @@ function createRegisteredOperations(
         force: Type.Optional(Type.Boolean()),
         agents_md: Type.Optional(Type.Boolean()),
       }),
-      run: (p) =>
-        apneaSetup(p as Parameters<typeof apneaSetup>[0], hostAdapter),
+      run: (p, hooks) =>
+        apneaSetup(p as Parameters<typeof apneaSetup>[0], hostAdapter, hooks),
     },
     {
       tool: "workflow_start",
@@ -115,7 +115,7 @@ function createRegisteredOperations(
       // Mirrors the guard in index.ts's execute(): without it, action=start
       // with no goal reaches slugify(undefined) in workflows/start.ts and
       // throws instead of returning a clean refusal.
-      run: (p) => {
+      run: (p, hooks) => {
         const params = p as Parameters<typeof workflowStart>[0]
         const action = params.action ?? "start"
         if (action === "start" && !params.goal?.trim()) {
@@ -132,16 +132,17 @@ function createRegisteredOperations(
             action,
           },
           hostAdapter,
+          hooks,
         )
       },
     },
     {
       tool: "dispatch_role",
       verb: "dispatch",
-      usage: "<kind> [--rework]",
+      usage: "<kind> [--rework] [--redeliver]",
       summary: "Write the task file and launch a role in a Herdr pane.",
       guidance:
-        "One outstanding dispatch at a time. Pass rework=true for plan/code after CHANGES_REQUIRED. Phase-package rework advances its round automatically from review frontmatter.",
+        "One outstanding dispatch at a time. Persisted review state selects rework and advances its round. rework=true is a deprecated assertion through 0.2.x and grants authority only for ambiguous version-1 plan or code migration. Use redeliver=true only to reuse matching pending ownership after proving the prior delivery is dead. A complete pending artifact refuses redelivery; call workflow_wait to ingest it.",
       params: operationParams({
         kind: DispatchKind,
         task_markdown: Type.Optional(
@@ -149,14 +150,22 @@ function createRegisteredOperations(
         ),
         rework: Type.Optional(
           Type.Boolean({
-            description: "Increment round after CHANGES_REQUIRED",
+            description:
+              "Deprecated assertion through 0.2.x; persisted state owns rework",
+          }),
+        ),
+        redeliver: Type.Optional(
+          Type.Boolean({
+            description:
+              "Reuse matching pending ownership after the prior delivery is demonstrably dead",
           }),
         ),
       }),
-      run: (p) =>
+      run: (p, hooks) =>
         workflowDispatch(
           p as Parameters<typeof workflowDispatch>[0],
           hostAdapter,
+          hooks,
         ),
     },
     {
@@ -180,8 +189,9 @@ function createRegisteredOperations(
       // moves, and then the schema promises a budget the runtime refuses.
       params: operationParams({
         poll_ms: Type.Optional(
-          Type.Number({
+          Type.Integer({
             minimum: MIN_POLL_MS,
+            maximum: Number.MAX_SAFE_INTEGER,
             description:
               `Milliseconds between polls. At least ${MIN_POLL_MS} — each poll spawns two herdr subprocesses. ` +
               `Keep it at or under ${MAX_AUTO_POLL_MS} unless you also pass budget_ms: above that, the floor ` +
@@ -189,7 +199,9 @@ function createRegisteredOperations(
           }),
         ),
         budget_ms: Type.Optional(
-          Type.Number({
+          Type.Integer({
+            minimum: 1,
+            maximum: Number.MAX_SAFE_INTEGER,
             description:
               `How long THIS call may block — not the role's deadline, which comes from config. ` +
               `Must be at least ${GRACE_MS} + max(${IDLE_NUDGE_AFTER_MS}, ${DEAD_POLLS_NEEDED} x poll_ms), so the call ` +
@@ -223,10 +235,11 @@ function createRegisteredOperations(
           }),
         ),
       }),
-      run: (p) =>
+      run: (p, hooks) =>
         workflowCommitPhase(
           p as Parameters<typeof workflowCommitPhase>[0],
           hostAdapter,
+          hooks,
         ),
     },
     {
@@ -236,7 +249,7 @@ function createRegisteredOperations(
       summary: "Read-only snapshot of run state and legal next calls.",
       guidance: "Never mutates. Safe to call at any point.",
       params: operationParams({}),
-      run: () => workflowStatus(hostAdapter),
+      run: (_p, hooks) => workflowStatus(hostAdapter, hooks),
     },
     {
       tool: null,
@@ -254,10 +267,11 @@ function createRegisteredOperations(
           description: "Round key, e.g. plan_review or phase-01/code_review",
         }),
       }),
-      run: (p) =>
+      run: (p, hooks) =>
         workflowResetRounds(
           p as Parameters<typeof workflowResetRounds>[0],
           hostAdapter,
+          hooks,
         ),
     },
   ]