@try-works/dsh-recursive-mode 0.2.3 → 0.3.0

package/src/goals-projection.ts

@@ -0,0 +1,149 @@
+/**
+ * goals-projection.ts (T1, STRENGTHENING-PLAN): project a recursive run into the
+ * native `goals` service so the run is a first-class durable, resumable,
+ * blockable object — and a gate block is durable + UI-visible rather than a
+ * one-line advisory.
+ *
+ * Pure/structural: this module takes a `GoalServiceLike` seam (the real
+ * `ctx.goals` satisfies it structurally) and an opaque `AgentHandle`, and never
+ * imports the host `@deepseek-ai/dsh-goal` package. The real service's methods
+ * take a live `Agent` and throw if the agent is not the registry's live
+ * instance, so callers pass the live agent from a tool/pre-step `exec`.
+ *
+ * Safety rule: the projection NEVER clobbers a foreign goal. A goal whose
+ * objective is not a `recursive-run:<id>` marker is left untouched (only a
+ * completed goal may be replaced, per the service contract).
+ */
+import type { RunState } from './lifecycle.ts'
+
+/** Native goal phase (mirrors @deepseek-ai/dsh-goal GoalPhase). */
+export type GoalPhase = 'active' | 'paused' | 'blocked' | 'complete'
+
+/** CSA identity for one exact goal revision. */
+export interface GoalRefLike {
+  id: string
+  revision: number
+}
+
+/** Input resolved by the service when the round cap is omitted. */
+export interface CreateGoalRequestLike {
+  objective: string
+  maxGoalRounds?: number
+}
+
+/** The subset of the goal view the projection reads. */
+export interface GoalViewLike extends GoalRefLike {
+  objective?: string
+  phase?: GoalPhase
+}
+
+/** Opaque handle to the live DSH Agent; the projection never inspects it further. */
+export interface AgentHandle {
+  session?: { header?: { cwd?: string } }
+}
+
+/** Structural seam for the live `goals` service (real methods return GoalView). */
+export interface GoalServiceLike {
+  get(agent: AgentHandle): GoalViewLike | undefined
+  create(agent: AgentHandle, req: CreateGoalRequestLike): GoalViewLike
+  block(agent: AgentHandle, ref: GoalRefLike, reason: { code: string; message: string }): GoalViewLike
+  pause(agent: AgentHandle, ref: GoalRefLike): GoalViewLike
+  resume(agent: AgentHandle, ref: GoalRefLike): GoalViewLike
+  complete(agent: AgentHandle, ref: GoalRefLike): GoalViewLike
+  clear(agent: AgentHandle, ref: GoalRefLike): GoalRefLike
+}
+
+/** Outcome of a run→goal sync. */
+export type SyncResult =
+  | { ok: true; phase: GoalPhase; ref?: GoalRefLike; created?: boolean }
+  | { ok: false; reason: string }
+
+/** Marker embedded in the goal objective so a goal can be matched to its run. */
+export function runGoalTag(runId: string): string {
+  return 'recursive-run:' + runId
+}
+
+/** The durable objective string for a run goal. */
+export function goalObjective(runId: string, runState: RunState = 'active'): string {
+  return runGoalTag(runId) + ' · ' + runState
+}
+
+/** Map a run state onto the native goal phase it should project to. */
+export const RUN_TO_GOAL_PHASE = {
+  new: 'active', active: 'active', paused: 'paused', blocked: 'blocked', complete: 'complete',
+} as const satisfies Record<RunState, GoalPhase>
+
+/** Is this goal's objective the marker for `runId`? */
+export function isRunGoal(goal: GoalViewLike | undefined, runId: string): boolean {
+  return goal?.objective?.startsWith(runGoalTag(runId)) === true
+}
+
+/** Read a live ref (id + revision) for a goal. */
+function refOf(goal: GoalViewLike): GoalRefLike {
+  return { id: goal.id, revision: goal.revision }
+}
+
+/** Commit a phase mutation; the real service returns a truthy GoalView on success. */
+function mutatePhase(service: GoalServiceLike, agent: AgentHandle, ref: GoalRefLike, target: GoalPhase): boolean {
+  switch (target) {
+    case 'blocked': return !!service.block(agent, ref, { code: 'run-gate-block', message: 'recursive run gate block' })
+    case 'paused': return !!service.pause(agent, ref)
+    case 'complete': return !!service.complete(agent, ref)
+    case 'active': return !!service.resume(agent, ref)
+  }
+}
+
+/**
+ * Sync a run's durable goal to the requested phase. Safe: never touches a goal
+ * whose objective is not this run's marker, and never re-creates over a
+ * non-complete foreign goal.
+ */
+export function syncRunGoal(service: GoalServiceLike | undefined | null, agent: AgentHandle, runId: string, runState: RunState): SyncResult {
+  if (!service) return { ok: false, reason: 'no goals service' }
+  const target = RUN_TO_GOAL_PHASE[runState]
+  const current = service.get(agent)
+
+  // 1. Existing goal for this run -> mutate to the requested phase (no-op at target).
+  if (current && isRunGoal(current, runId)) {
+    const phase = current.phase ?? 'active'
+    const ref = refOf(current)
+    if (phase === target) return { ok: true, phase: target, ref }
+    // A completed goal is final: the contract allows it to be REPLACED, not resumed.
+    if (phase === 'complete') {
+      const created = service.create(agent, { objective: goalObjective(runId, runState) })
+      return { ok: true, phase: target, ref: refOf(created), created: true }
+    }
+    const ok = mutatePhase(service, agent, ref, target)
+    return ok ? { ok: true, phase: target, ref } : { ok: false, reason: 'goal mutation failed' }
+  }
+
+  // 2. A completed goal may be replaced; every other current phase must be
+  //    cleared or resumed instead. Never clobber a foreign goal.
+  if (current) {
+    if (current.phase === 'complete') {
+      const created = service.create(agent, { objective: goalObjective(runId, runState) })
+      return { ok: true, phase: target, ref: refOf(created), created: true }
+    }
+    return { ok: false, reason: 'a non-matching active goal exists (foreign goal not touched)' }
+  }
+
+  // 3. No current goal -> create and arm.
+  const created = service.create(agent, { objective: goalObjective(runId, runState) })
+  return { ok: true, phase: target, ref: refOf(created), created: true }
+}
+
+/** Block the current run goal (used on a gate-block). Never touches a foreign goal. */
+export function blockRunGoal(service: GoalServiceLike | undefined | null, agent: AgentHandle, runId: string, reason: { code: string; message: string }): SyncResult {
+  if (!service) return { ok: false, reason: 'no goals service' }
+  const current = service.get(agent)
+  if (!current) return { ok: false, reason: 'no current goal to block' }
+  if (!isRunGoal(current, runId)) return { ok: false, reason: 'current goal is not for this run (foreign goal not touched)' }
+  const ref = refOf(current)
+  const ok = !!service.block(agent, ref, reason)
+  return ok ? { ok: true, phase: 'blocked', ref } : { ok: false, reason: 'goal block failed' }
+}
+
+/** Bridge a run's blocked goal back to active (used on a reopen). */
+export function resumeRunGoal(service: GoalServiceLike | undefined | null, agent: AgentHandle, runId: string): SyncResult {
+  return syncRunGoal(service, agent, runId, 'active')
+}

package/src/index.ts

@@ -9,10 +9,13 @@ import { createRecursiveLockTool } from './recursive_lock.tool.ts'
 import { createRecursiveLintTool } from './recursive_lint.tool.ts'
 import { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 import { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
-import { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+import { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
 import { createRecursivePhaseTool } from './recursive_phase.tool.ts'
+import { createRecursiveAuditTeamTool } from './recursive_audit_team.tool.ts'
 import { registerRecursiveCommand } from './commands.ts'
-import { evaluateToolGuard } from './enforcement.ts'
+import { evaluateToolGuard, coerceAskToDecision } from './enforcement.ts'
+import type { GoalServiceLike } from './goals-projection.ts'
+import type { TeamRuntimeLike } from './teams-loop.ts'
 import { renderRecursivePolicy } from './policy.ts'
 import { fsPolicyIntent } from './fs-intent.ts'
 import { snapshotWorkspace } from './snapshot.ts'
@@ -30,7 +33,7 @@ export { createRecursiveLockTool } from './recursive_lock.tool.ts'
 export { createRecursiveLintTool } from './recursive_lint.tool.ts'
 export { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 export { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
-export { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+export { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
 export { createRecursivePhaseTool } from './recursive_phase.tool.ts'
 export * from './status.ts'
 export {
@@ -70,6 +73,7 @@ export * from './enforcement.ts'
 export * from './policy.ts'
 export * from './snapshot.ts'
 export * from './live-route.ts'
+export * from './teams-loop.ts'
 
 /**
  * Bundle plugin entry. The Loader activates this row once `tools` is available
@@ -101,10 +105,26 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
     // property access requires inject and would fail boot when undeclared.
     // Resolve the control-plane root strictly from the session agent's cwd.
     const workspaceRegistry = ctx.get('workspaceRegistry') as never
-    const recursive = new RecursiveRuntime(ctx, { repoRoot: config?.repoRoot ?? process.cwd(), workspaceRegistry })
+    // T1 (goals projection): the goals service is on the host plane; it resolves
+    // from inside the recursive-realm via inheritance (same as workspaceRegistry).
+    // SAFETY: the goals service is an optional host service (could be absent); the
+    // run projection treats null as "no goal backing" and never throws.
+    const goals = ctx.get('goals') as GoalServiceLike | null
+    const recursive = new RecursiveRuntime(ctx, { repoRoot: config?.repoRoot ?? process.cwd(), workspaceRegistry, goals })
 
-    const repairedRoots = new Set<string>()
+    const repairedRoots = new Set<string>()
     const reminderGate = new ReminderOnceGate()
+    // T3 (agentTeams task loop): wire the live ctx.agentTeams service (optional —
+    // absent in compositions without the experimental agent-team row) into the
+    // turn-driven task-board tool. The whole-loop driver (auditToPass) is also
+    // exported for callers with a settlement observer.
+    // SAFETY: ctx.get returns the live service as an opaque value; the single
+    // boundary cast asserts it satisfies the TeamRuntimeLike structural seam
+    // (createTask/updateTask plus optional wait/interrupt/board reads). The
+    // live service's real Agent parameter is a superset of TeamCallerHandle, so
+    // the seam passes the exact live Agent the tool extracts from exec.agent.
+    const agentTeams = ctx.get('agentTeams') as TeamRuntimeLike | undefined
+
     const disposers = [
       ctx.tools.register(createRecursiveStatusTool(recursive)),
       ctx.tools.register(createRecursiveInitTool(recursive)),
@@ -112,8 +132,9 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
       ctx.tools.register(createRecursiveLintTool(recursive)),
       ctx.tools.register(createRecursiveCloseoutTool(recursive)),
       ctx.tools.register(createRecursiveScratchTool(recursive)),
-      ctx.tools.register(createRecursiveWorktreeTool(recursive)),
+      ctx.tools.register(createRecursiveWorktreeTool(recursive)),
       ctx.tools.register(createRecursivePhaseTool(recursive)),
+      ...(agentTeams ? [ctx.tools.register(createRecursiveAuditTeamTool(agentTeams))] : []),
     ]
 
     // /recursive command (R4): preset-scoped registration, workspace-scoped dispatch.
@@ -167,7 +188,16 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
         const decision = evaluateToolGuard(exec as never, root, '', recursive.enforcementConfig.toolGuards)
         if (decision.kind === 'allow') return typeof next === 'function' ? next() : { kind: 'allow' }
         if (decision.kind === 'deny') return decision
-        // ask -> in advisory we let it through with a warn (the approval seam is Phase D)
+        // T6 (approval ask→policy bridge): an `ask` must never be a silent
+        // allow. Strict coerces to deny; advisory allows but carries a warn that
+        // the caller logs below. The approval seam is the follow-on (Phase D).
+        const coerced = coerceAskToDecision(decision, recursive.enforcementConfig.toolGuards)
+        if (coerced.kind === 'deny') return coerced
+        if (coerced.kind === 'allow' && coerced.warn) {
+          // Package-tagged host logging; never a silent pass under approval=never.
+          console.warn('[recursive] tool guard (advisory): ' + coerced.warn + ' — allowing')
+        }
+        return typeof next === 'function' ? next() : { kind: 'allow' }
       }))
     }
 
@@ -212,10 +242,10 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
         const phasePath = join(runDir, phase)
         const status = existsSync(phasePath) ? getLockStatus(phasePath) : null
         if (status !== 'DRAFT') return { kind: 'enter', messages } as const
-        if (!reminderGate.shouldInject(root, runId, phase)) return { kind: 'enter', messages } as const
-                // LIVE BUG 6 (0.2.1): inject the lint-rules reminder AT MOST ONCE PER PHASE.
-                // The scaffold repair above is deduped via repairedRoots; the reminder itself was
-                // not, so every pre-step while DRAFT re-injected it.
+        if (!reminderGate.shouldInject(root, runId, phase)) return { kind: 'enter', messages } as const
+                // LIVE BUG 6 (0.2.1): inject the lint-rules reminder AT MOST ONCE PER PHASE.
+                // The scaffold repair above is deduped via repairedRoots; the reminder itself was
+                // not, so every pre-step while DRAFT re-injected it.
                 const reminder = phaseLintRulesMessage(phase)
         return {
           kind: 'enter',

package/src/live-route.ts

@@ -17,7 +17,10 @@
  * would be both wrong and a crash).
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve, sep } from 'node:path'
 import type { RecursiveProjection } from './types.ts'
+import { RUN_ARTIFACT_SEQUENCE } from './status.ts'
 
 /** API prefix the board/strip fetch. */
 export const RECURSIVE_API_PREFIX = '/.recursive/api'
@@ -65,8 +68,72 @@ function queryOf(req: IncomingMessage, name: string): string {
   return new URLSearchParams(url.slice(q + 1)).get(name) ?? ''
 }
 
+/** Phase-doc basename allowlist (the run artifact sequence: single *.md, no subdirs). */
+const PHASE_DOC_FILES = new Set(RUN_ARTIFACT_SEQUENCE)
+
+/** runId/file safety: alphanumerics, dot, underscore, dash only; no '..', no separators. */
+const DOC_SAFE_RE = /^[A-Za-z0-9._-]+$/
+
+/** Invalid runId or file name (path traversal / subdir / non-phase doc) — reject. */
+function docTargetError(runId: string, file: string): string | null {
+  if (!DOC_SAFE_RE.test(runId) || runId.includes('..')) return 'invalid runId'
+  if (!DOC_SAFE_RE.test(file) || file.includes('..') || file.includes('/') || file.includes('\\')) return 'invalid file'
+  if (!file.endsWith('.md')) return 'invalid file: must be a .md phase doc'
+  if (!PHASE_DOC_FILES.has(file)) return 'invalid file: not a phase doc'
+  return null
+}
+
+/**
+ * The lazy per-phase doc route (0.2.4): GET the raw markdown of one run phase
+ * doc, read ON DEMAND from the filesystem. NOT part of the /state or /events
+ * projection payloads (they stay fold-only). Same browser-marker tripwire as
+ * state/events; the client root is re-validated by the host (never trusted:
+ * an unknown root -> 400), then the resolved doc path is containment-checked
+ * under join(root, '.recursive', 'run', runId).
+ */
+function docRoute(host: RecursiveRouteHost) {
+  return {
+    kind: 'exact' as const,
+    path: RECURSIVE_API_PREFIX + '/doc',
+    handler: async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+      if (req.method !== 'GET') { res.writeHead(405); res.end(); return }
+      if (!browserMarker(req)) { res.writeHead(403); res.end(); return }
+      const root = queryOf(req, 'root')
+      const runId = queryOf(req, 'runId')
+      const file = queryOf(req, 'file')
+      const targetError = docTargetError(runId, file)
+      if (root === '' || targetError !== null) {
+        json(res, 400, { ok: false, error: targetError ?? 'missing root' })
+        return
+      }
+      // Root validation: the client passes back what the host already resolved.
+      // Re-resolve via the host and require a canonical match — never accept an
+      // arbitrary path (registry know-it or headless cwd pass-through).
+      const resolvedRoot = await host.resolveRoot(undefined, root)
+      if (resolvedRoot === null || resolve(resolvedRoot) !== resolve(root)) {
+        json(res, 400, { ok: false, error: 'root is not a known workspace' })
+        return
+      }
+      // Containment: the doc must stay under join(root, .recursive, run, runId).
+      const runBase = resolve(root, '.recursive', 'run', runId)
+      const docPath = resolve(runBase, file)
+      if (docPath === runBase || !docPath.startsWith(runBase + sep)) {
+        json(res, 400, { ok: false, error: 'doc path escapes the run dir' })
+        return
+      }
+      if (!existsSync(docPath)) {
+        json(res, 404, { ok: false, error: 'phase doc not found' })
+        return
+      }
+      const text = readFileSync(docPath, 'utf8')
+      res.writeHead(200, { 'content-type': 'text/markdown; charset=utf-8', 'cache-control': 'no-store' })
+      res.end(text)
+    },
+  }
+}
+
 /**
- * Build the two read-only routes. Returns [state, events] in registration order.
+ * Build the read-only routes. Returns [state, events, doc] in registration order.
  * @param host - the resolved-root + fs-fold seam (the RecursiveRuntime adapter).
  */
 export function makeRecursiveRoutes(host: RecursiveRouteHost): readonly { kind: 'exact'; path: string; handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void> }[] {
@@ -109,7 +176,7 @@ export function makeRecursiveRoutes(host: RecursiveRouteHost): readonly { kind:
       await push()
     },
   }
-  return [state, events]
+  return [state, events, docRoute(host)]
 }
 
 /**

package/src/recursive_audit_team.tool.ts

@@ -0,0 +1,141 @@
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import type { JsonValue } from '@deepseek-ai/dsh-tools'
+import type {
+  TeamRuntimeLike,
+  TeamCallerHandle,
+  TeamTaskActionLike,
+  TeamTaskViewLike,
+  CreateTeamTaskRequestLike,
+  UpdateTeamTaskRequestLike,
+} from './teams-loop.ts'
+
+/**
+ * `recursive_audit_team` — the T3 entry path: a turn-driven adapter over the
+ * live `agentTeams` task board. ONE call advances the audit→repair→re-audit
+ * state machine by one transition, so the agent drives the loop across turns
+ * as continuable-child settlement notices arrive in its inbox.
+ *
+ * Why one step per call: the live subagents service has no public parent-side
+ * "await settlement" promise — a continuable child's verdict arrives as a
+ * `subagent-settled` message on a LATER turn. The pure whole-loop driver
+ * (`auditToPass` in teams-loop.ts) models the full state machine and is the
+ * tested reference; this tool is its honest turn-driven shell.
+ */
+
+/** Project one live task view to an owned, lossless-JSON-safe record. */
+function taskViewToJson(view: TeamTaskViewLike): JsonValue {
+  // Read only leaf fields; never pass the live service object into the model
+  // context (the tool boundary is where a live view becomes owned JSON).
+  return {
+    id: view.id,
+    revision: view.revision,
+    subject: view.subject,
+    description: view.description,
+    status: view.status,
+    blockedBy: [...view.blockedBy],
+    writeScopes: [...view.writeScopes],
+    ownerName: view.ownerName ?? null,
+    ready: view.ready,
+    writeScopeWarnings: [...view.writeScopeWarnings],
+  }
+}
+
+/** Wrap a non-JSON-pure value in the standard error envelope. */
+function errorJson(message: string): JsonValue {
+  return { error: message }
+}
+
+export function createRecursiveAuditTeamTool(teams: TeamRuntimeLike | null) {
+  return defineTool({
+    name: 'recursive_audit_team',
+    description: 'Advance one agentTeams Task-board transition for the recursive audit loop (create → claim → edit(REVISE) → complete(APPROVE) → release/interrupt). Drive one step per turn as continuable-child settlement notices arrive; complete the task (and lock the phase) ONLY after an APPROVE verdict.',
+    parameters: {
+      action: { type: 'string', description: 'create | claim | edit | complete | release | interrupt | get | list. Required.' },
+      taskId: { type: 'string', description: 'Task id for claim/edit/complete/release/interrupt/get.' },
+      expectedRevision: { type: 'number', description: 'CAS revision for claim/edit/complete/release.' },
+      subject: { type: 'string', description: 'Task subject (create).' },
+      description: { type: 'string', description: 'Task description (create) or appended repair note (edit).' },
+      blockedBy: { type: 'array', items: { type: 'string' }, description: 'Task blockers (create).' },
+      writeScopes: { type: 'array', items: { type: 'string' }, description: 'Advisory write scopes (create).' },
+      targetName: { type: 'string', description: 'Teammate name to interrupt (interrupt).' },
+    },
+    output: {
+      schema: { type: 'json' },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    },
+    async execute(args: {
+      action?: string
+      taskId?: string
+      expectedRevision?: number
+      subject?: string
+      description?: string
+      blockedBy?: string[]
+      writeScopes?: string[]
+      targetName?: string
+    }, exec) {
+      const action = args.action ?? ''
+      if (!teams) return errorJson('agentTeams service is not available in this composition')
+      // SAFETY: exec.agent is the live Team member Agent (a superset of the
+      // named opaque handle); the seam reads only id/session identity and never
+      // serializes it. When no agent owns the call, an empty handle degrades to
+      // an anonymous caller (the service admits/denies by its own authority).
+      const caller: TeamCallerHandle = exec.agent ?? {}
+
+      try {
+        switch (action) {
+          case 'create': {
+            if (!args.subject || !args.description) return errorJson('create requires subject and description')
+            const createRequest: CreateTeamTaskRequestLike = {
+              subject: args.subject,
+              description: args.description,
+            }
+            if (args.blockedBy !== undefined) createRequest.blockedBy = args.blockedBy
+            if (args.writeScopes !== undefined) createRequest.writeScopes = args.writeScopes
+            const view = await teams.createTask(caller, createRequest)
+            return taskViewToJson(view)
+          }
+          case 'claim':
+          case 'edit':
+          case 'complete':
+          case 'release': {
+            if (!args.taskId || args.expectedRevision === undefined) {
+              return errorJson(action + ' requires taskId and expectedRevision')
+            }
+            // SAFETY: this case arm is reachable only for action 'claim' | 'edit' |
+            // 'complete' | 'release' (the switch discriminates on the same string),
+            // each a member of TeamTaskActionLike's subset; the cast re-asserts that
+            // narrowing across the four fall-through labels without widening scope.
+            const updateAction = action as TeamTaskActionLike
+            const updateRequest: UpdateTeamTaskRequestLike = {
+              taskId: args.taskId,
+              expectedRevision: args.expectedRevision,
+              action: updateAction,
+            }
+            if (action === 'edit' && args.description !== undefined) updateRequest.description = args.description
+            const view = await teams.updateTask(caller, updateRequest)
+            return taskViewToJson(view)
+          }
+          case 'interrupt': {
+            if (!args.targetName) return errorJson('interrupt requires targetName')
+            if (!teams.interrupt) return errorJson('no interrupt seam')
+            const outcome = teams.interrupt(caller, args.targetName)
+            return { previousStatus: outcome.previousStatus }
+          }
+          case 'get': {
+            if (!args.taskId) return errorJson('get requires taskId')
+            if (!teams.getTask) return errorJson('no getTask seam')
+            return taskViewToJson(teams.getTask(caller, args.taskId))
+          }
+          case 'list': {
+            if (!teams.listTasks) return errorJson('no listTasks seam')
+            return teams.listTasks(caller).map(taskViewToJson)
+          }
+          default:
+            return errorJson('unsupported action: ' + action + ' (create|claim|edit|complete|release|interrupt|get|list)')
+        }
+      } catch (err) {
+        return errorJson(err instanceof Error ? err.message : String(err))
+      }
+    },
+  })
+}