maestro-flow 0.3.4 → 0.3.6

package/.codex/skills/spec-add/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: maestro-spec-add
+name: spec-add
 description: Add a spec entry (bug, pattern, decision, or rule) to the appropriate specs file
 argument-hint: "<type> <content>"
 allowed-tools: Read, Write, Bash, Glob, Grep
@@ -10,10 +10,10 @@ allowed-tools: Read, Write, Bash, Glob, Grep
 ## Usage
 
 ```bash
-$maestro-spec-add "pattern Always use named exports for utility functions"
-$maestro-spec-add "bug Off-by-one in pagination when page=0"
-$maestro-spec-add "decision Use Zod for runtime validation over io-ts"
-$maestro-spec-add "rule All API endpoints must return structured error objects"
+$spec-add "pattern Always use named exports for utility functions"
+$spec-add "bug Off-by-one in pagination when page=0"
+$spec-add "decision Use Zod for runtime validation over io-ts"
+$spec-add "rule All API endpoints must return structured error objects"
 ```
 
 **Arguments**: `<type> <content>` where type is one of: bug, pattern, decision, rule, debug, test, review, validation.

package/.codex/skills/spec-load/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: maestro-spec-load
+name: spec-load
 description: Load relevant specs for current context, optionally filtered by category or keyword
 argument-hint: "[--category <type>] [keyword]"
 allowed-tools: Read, Bash, Glob, Grep
@@ -10,10 +10,10 @@ allowed-tools: Read, Bash, Glob, Grep
 ## Usage
 
 ```bash
-$maestro-spec-load
-$maestro-spec-load "--category execution"
-$maestro-spec-load "authentication"
-$maestro-spec-load "--category debug error handling"
+$spec-load
+$spec-load "--category execution"
+$spec-load "authentication"
+$spec-load "--category debug error handling"
 ```
 
 **Flags**: `--category <type>` filters by spec category. Optional keyword searches within loaded files.

package/.codex/skills/spec-map/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: maestro-spec-map
+name: spec-map
 description: Analyze codebase with 4 parallel mapper agents via CSV wave pipeline. Produces .workflow/codebase/ documents for tech-stack, architecture, features, and cross-cutting concerns.
 argument-hint: "[-y|--yes] [-c|--concurrency 4] [--continue] \"[focus area]\""
 allowed-tools: spawn_agents_on_csv, Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
@@ -14,10 +14,10 @@ When `--yes` or `-y`: Auto-confirm mapper assignment, skip validation.
 ## Usage
 
 ```bash
-$maestro-spec-map ""
-$maestro-spec-map "auth"
-$maestro-spec-map -c 4 "api layer"
-$maestro-spec-map --continue "map-auth-20260318"
+$spec-map ""
+$spec-map "auth"
+$spec-map -c 4 "api layer"
+$spec-map --continue "map-auth-20260318"
 ```
 
 **Flags**:

package/.codex/skills/spec-setup/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: maestro-spec-setup
+name: spec-setup
 description: Initialize project specs by scanning codebase for conventions and tech stack
 argument-hint: ""
 allowed-tools: Read, Write, Bash, Glob, Grep
@@ -10,7 +10,7 @@ allowed-tools: Read, Write, Bash, Glob, Grep
 ## Usage
 
 ```bash
-$maestro-spec-setup
+$spec-setup
 ```
 
 No arguments. Scans the codebase and generates spec files in `.workflow/specs/`.

package/.codex/skills/team-coordinate/SKILL.md

@@ -160,7 +160,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target: <name> })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target: <name> })` each worker.
 
 **Inner Loop roles** (role has 2+ serial same-prefix tasks): Set `inner_loop: true`. The team-worker agent handles the loop internally.
 

package/.codex/skills/team-coordinate/roles/coordinator/commands/monitor.md

@@ -226,7 +226,7 @@ Report blockers immediately via team_msg type="blocker".
 Report completion via team_msg type="task_complete" after report_agent_job_result.`
 })
 // Collect results — use task_name for stable targeting (v4):
-const result = wait_agent({ timeout_ms: 900000 })
+const result = wait_agent({ timeout_ms: 1800000 })  // 30 min
 
 // Drain progress from message bus (before processing results)
 const progressMsgs = mcp__maestro-tools__team_msg({
@@ -237,15 +237,24 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 }
 
 if (result.timed_out) {
-  // Use progress trace for timeout forensics
-  const lastProgress = (progressMsgs.result?.messages || [])
-    .filter(m => m.data?.task_id === taskId).pop()
-  state.tasks[taskId].status = 'timed_out'
-  state.tasks[taskId].error = lastProgress
-    ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-    : 'Timed out with no progress reported'
-  close_agent({ target: taskId })
-  // Report timeout, STOP — let user decide retry
+  // Status probe before closing
+  followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+  const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+  if (status.timed_out) {
+    followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+    const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (forced.timed_out) {
+      const lastProgress = (progressMsgs.result?.messages || [])
+        .filter(m => m.data?.task_id === taskId).pop()
+      state.tasks[taskId].status = 'timed_out'
+      state.tasks[taskId].error = lastProgress
+        ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+        : 'Timed out with no progress reported'
+      close_agent({ target: taskId })
+    }
+    // else: forced output received, process result
+  }
+  // else: status received, continue processing
 } else {
   // Process result, update tasks.json
   close_agent({ target: taskId })  // Use task_name, not agentId

package/.codex/skills/team-coordinate/roles/coordinator/role.md

@@ -31,7 +31,7 @@ OK: Write(".workflow/.team/TC-xxx/tasks.json", ...)   — task management
 OK: Read("roles/coordinator/commands/analyze-task.md") — own instructions
 OK: Read("specs/role-spec-template.md")               — generating role-specs
 OK: spawn_agent({ agent_type: "team_worker", ... })   — delegation
-OK: wait_agent({ timeout_ms: 900000 })     — monitoring
+OK: wait_agent({ timeout_ms: 1800000 })     — monitoring (30 min)
 ```
 
 **Self-check gate**: After Phase 1 analysis, before ANY other action, ask yourself:
@@ -380,7 +380,7 @@ Delegate to `@commands/dispatch.md` which creates the full task chain:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/.codex/skills/team-executor/SKILL.md

@@ -132,7 +132,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target: <name> })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target: <name> })` each worker.
 
 ---
 

package/.codex/skills/team-executor/roles/executor/commands/monitor.md

@@ -189,7 +189,7 @@ After spawning all ready tasks:
 const agentIds = Object.values(state.active_agents)
   .filter(a => !a.resident)
   .map(a => a.agentId)
-const waitResult = wait_agent({ timeout_ms: 900000 })
+const waitResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
 
 // Drain progress from message bus
 const progressMsgs = mcp__maestro-tools__team_msg({
@@ -202,14 +202,25 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 if (waitResult.timed_out) {
   for (const [taskId, agent] of Object.entries(state.active_agents)) {
     if (agent.resident) continue
-    const lastProgress = (progressMsgs.result?.messages || [])
-      .filter(m => m.data?.task_id === taskId).pop()
-    state.tasks[taskId].status = 'timed_out'
-    state.tasks[taskId].error = lastProgress
-      ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-      : 'Timed out with no progress reported'
-    close_agent({ target: agent.agentId })
-    delete state.active_agents[taskId]
+    // Status probe before closing
+    followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+    const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (status.timed_out) {
+      followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+      const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+      if (forced.timed_out) {
+        const lastProgress = (progressMsgs.result?.messages || [])
+          .filter(m => m.data?.task_id === taskId).pop()
+        state.tasks[taskId].status = 'timed_out'
+        state.tasks[taskId].error = lastProgress
+          ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+          : 'Timed out with no progress reported'
+        close_agent({ target: agent.agentId })
+        delete state.active_agents[taskId]
+      }
+      // else: forced output received, process result
+    }
+    // else: status received, continue processing
   }
 } else {
   // Collect results from discoveries/{task_id}.json

package/.codex/skills/team-lifecycle-v4/SKILL.md

@@ -153,7 +153,7 @@ task_id: <CHECKPOINT-NNN>
 scope: [<upstream-task-ids>]
 pipeline_progress: <done>/<total> tasks completed`
 })
-wait_agent({ timeout_ms: 600000 })
+wait_agent({ timeout_ms: 1800000 })  // 30 min
 ```
 
 ### Shutdown (pipeline complete)
@@ -196,7 +196,7 @@ For each wave in the pipeline:
 3. **Build upstream context** -- For each task, gather findings from `context_from` tasks via tasks.json and `discoveries/{id}.json`
 4. **Separate task types** -- Split into regular tasks and CHECKPOINT tasks
 5. **Spawn regular tasks** -- For each regular task, call `spawn_agent({ agent_type: "team_worker", message: "..." })`, collect agent IDs
-6. **Wait** -- `wait_agent({ timeout_ms: 900000 })`
+6. **Wait** -- `wait_agent({ timeout_ms: 1800000 })` (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents.
 7. **Collect results** -- Read `discoveries/{task_id}.json` for each agent, update tasks.json status/findings/error, then `close_agent({ target })` each worker
 8. **Execute checkpoints** -- For each CHECKPOINT task, `followup_task` to supervisor, `wait_agent`, read checkpoint report from `artifacts/`, parse verdict
 9. **Handle block** -- If verdict is `block`, prompt user via `request_user_input` with options: Override / Revise upstream / Abort

package/.codex/skills/team-lifecycle-v4/roles/coordinator/commands/monitor.md

@@ -151,7 +151,7 @@ After spawning all ready regular tasks:
 const taskNames = Object.entries(state.active_agents)
   .filter(([_, a]) => !a.resident)
   .map(([taskId]) => taskId)
-const waitResult = wait_agent({ timeout_ms: 900000 })
+const waitResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
 // 4a) Drain progress from message bus (before collecting discoveries)
 const progressMsgs = mcp__maestro-tools__team_msg({
   operation: "list", session_id: sessionId, type: "progress", last: 100
@@ -173,15 +173,26 @@ if (blockerMsgs.result?.messages?.length > 0) {
 if (waitResult.timed_out) {
   // Use progress trace to understand where workers got stuck
   for (const taskId of taskNames) {
-    const lastProgress = (progressMsgs.result?.messages || [])
-      .filter(m => m.data?.task_id === taskId)
-      .pop()
-    state.tasks[taskId].status = 'timed_out'
-    state.tasks[taskId].error = lastProgress
-      ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-      : 'Timed out with no progress reported'
-    close_agent({ target: taskId })
-    delete state.active_agents[taskId]
+    // Status probe before closing
+    followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+    const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (status.timed_out) {
+      followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+      const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+      if (forced.timed_out) {
+        const lastProgress = (progressMsgs.result?.messages || [])
+          .filter(m => m.data?.task_id === taskId)
+          .pop()
+        state.tasks[taskId].status = 'timed_out'
+        state.tasks[taskId].error = lastProgress
+          ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+          : 'Timed out with no progress reported'
+        close_agent({ target: taskId })
+        delete state.active_agents[taskId]
+      }
+      // else: forced output received, process result
+    }
+    // else: status received, continue processing
   }
 } else {
   // 5) Collect results from discoveries/{task_id}.json
@@ -234,8 +245,16 @@ For each ready CHECKPOINT task:
    scope: [${task.deps.join(', ')}]
    pipeline_progress: ${completedCount}/${totalCount} tasks completed`
    })
-   const cpResult = wait_agent({ timeout_ms: 600000 })
-   if (cpResult.timed_out) { /* mark checkpoint timed_out, close supervisor, STOP */ }
+   const cpResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
+   if (cpResult.timed_out) {
+     followup_task({ target: supervisorId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+     const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+     if (status.timed_out) {
+       followup_task({ target: supervisorId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+       const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+       if (forced.timed_out) { /* mark checkpoint timed_out, close supervisor, STOP */ }
+     }
+   }
    ```
 4. Read checkpoint report from artifacts/${task.id}-report.md
 5. Parse verdict (pass / warn / block):

package/.codex/skills/team-lifecycle-v4/roles/coordinator/role.md

@@ -170,7 +170,7 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/.codex/skills/team-quality-assurance/SKILL.md

@@ -110,7 +110,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target })` each worker.
 
 
 ### Model Selection Guide

package/.codex/skills/team-quality-assurance/roles/coordinator/commands/monitor.md

@@ -188,7 +188,7 @@ Report completion via team_msg type="task_complete" after report_agent_job_resul
 
    f. Add to active_workers
 5. Update session, output summary, STOP
-6. Use `wait_agent({ timeout_ms: 900000 })` to wait for callbacks. Workers use `report_agent_job_result()` to send results back.
+6. Use `wait_agent({ timeout_ms: 1800000 })` to wait for callbacks (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Workers use `report_agent_job_result()` to send results back.
 
 ### Post-Wait Processing
 
@@ -205,14 +205,25 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 
 if (waitResult.timed_out) {
   for (const taskId of Object.keys(state.active_workers)) {
-    const lastProgress = (progressMsgs.result?.messages || [])
-      .filter(m => m.data?.task_id === taskId).pop()
-    state.tasks[taskId].status = 'timed_out'
-    state.tasks[taskId].error = lastProgress
-      ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-      : 'Timed out with no progress reported'
-    close_agent({ target: taskId })
-    delete state.active_workers[taskId]
+    // Status probe before closing
+    followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+    const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (status.timed_out) {
+      followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+      const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+      if (forced.timed_out) {
+        const lastProgress = (progressMsgs.result?.messages || [])
+          .filter(m => m.data?.task_id === taskId).pop()
+        state.tasks[taskId].status = 'timed_out'
+        state.tasks[taskId].error = lastProgress
+          ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+          : 'Timed out with no progress reported'
+        close_agent({ target: taskId })
+        delete state.active_workers[taskId]
+      }
+      // else: forced output received, process result
+    }
+    // else: status received, continue processing
   }
 } else {
   // Collect results, mark completed, close agents

package/.codex/skills/team-quality-assurance/roles/coordinator/role.md

@@ -157,7 +157,7 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/.codex/skills/team-review/SKILL.md

@@ -108,7 +108,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target })` each worker.
 
 
 ### Model Selection Guide

package/.codex/skills/team-review/roles/coordinator/commands/monitor.md

@@ -144,7 +144,7 @@ Report completion via team_msg type="task_complete" after report_agent_job_resul
 state.active_agents[taskId] = { agentId, role, started_at: now }
 
 // 4) Wait for completion — use task_name for stable targeting (v4)
-const waitResult = wait_agent({ timeout_ms: 900000 })
+const waitResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
 
 // Drain progress from message bus
 const progressMsgs = mcp__maestro-tools__team_msg({
@@ -155,14 +155,25 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 }
 
 if (waitResult.timed_out) {
-  const lastProgress = (progressMsgs.result?.messages || [])
-    .filter(m => m.data?.task_id === taskId).pop()
-  state.tasks[taskId].status = 'timed_out'
-  state.tasks[taskId].error = lastProgress
-    ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-    : 'Timed out with no progress reported'
-  close_agent({ target: taskId })
-  delete state.active_agents[taskId]
+  // Status probe before closing
+  followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+  const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+  if (status.timed_out) {
+    followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+    const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (forced.timed_out) {
+      const lastProgress = (progressMsgs.result?.messages || [])
+        .filter(m => m.data?.task_id === taskId).pop()
+      state.tasks[taskId].status = 'timed_out'
+      state.tasks[taskId].error = lastProgress
+        ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+        : 'Timed out with no progress reported'
+      close_agent({ target: taskId })
+      delete state.active_agents[taskId]
+    }
+    // else: forced output received, process result
+  }
+  // else: status received, continue processing
 } else {
   // 5) Collect results
   state.tasks[taskId].status = 'completed'

package/.codex/skills/team-review/roles/coordinator/role.md

@@ -157,7 +157,7 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/.codex/skills/team-tech-debt/SKILL.md

@@ -110,7 +110,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target })` each worker.
 
 
 ### Model Selection Guide

package/.codex/skills/team-tech-debt/roles/coordinator/commands/monitor.md

@@ -150,7 +150,7 @@ After spawning all ready tasks:
 ```javascript
 // 4) Batch wait — use task_name for stable targeting (v4)
 const taskNames = Object.keys(state.active_agents)
-const waitResult = wait_agent({ timeout_ms: 900000 })
+const waitResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
 
 // Drain progress from message bus
 const progressMsgs = mcp__maestro-tools__team_msg({
@@ -162,14 +162,25 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 
 if (waitResult.timed_out) {
   for (const taskId of taskNames) {
-    const lastProgress = (progressMsgs.result?.messages || [])
-      .filter(m => m.data?.task_id === taskId).pop()
-    state.tasks[taskId].status = 'timed_out'
-    state.tasks[taskId].error = lastProgress
-      ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-      : 'Timed out with no progress reported'
-    close_agent({ target: taskId })
-    delete state.active_agents[taskId]
+    // Status probe before closing
+    followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+    const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (status.timed_out) {
+      followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+      const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+      if (forced.timed_out) {
+        const lastProgress = (progressMsgs.result?.messages || [])
+          .filter(m => m.data?.task_id === taskId).pop()
+        state.tasks[taskId].status = 'timed_out'
+        state.tasks[taskId].error = lastProgress
+          ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+          : 'Timed out with no progress reported'
+        close_agent({ target: taskId })
+        delete state.active_agents[taskId]
+      }
+      // else: forced output received, process result
+    }
+    // else: status received, continue processing
   }
 } else {
   // 5) Collect results

package/.codex/skills/team-tech-debt/roles/coordinator/role.md

@@ -153,7 +153,7 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/.codex/skills/team-testing/SKILL.md

@@ -109,7 +109,7 @@ pipeline_phase: <pipeline-phase>
 })
 ```
 
-After spawning, use `wait_agent({ timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.
+After spawning, use `wait_agent({ timeout_ms: 1800000 })` to collect results (30 min). If `result.timed_out`, send STATUS_CHECK via followup_task (wait 3 min), then FINALIZE with interrupt (wait 3 min), then mark timed_out and close agents. Use `close_agent({ target })` each worker.
 
 
 ### Model Selection Guide
@@ -162,7 +162,7 @@ const genNames = ["TESTGEN-001", "TESTGEN-002"]
 for (const name of genNames) {
   spawn_agent({ agent_type: "team_worker", task_name: name, ... })
 }
-wait_agent({ timeout_ms: 900000 })
+wait_agent({ timeout_ms: 1800000 })  // 30 min
 ```
 
 ### GC Loop Coordination

package/.codex/skills/team-testing/roles/coordinator/commands/monitor.md

@@ -172,7 +172,7 @@ After spawning all ready tasks:
 ```javascript
 // 4) Batch wait — use task_name for stable targeting (v4)
 const taskNames = Object.keys(state.active_agents)
-const waitResult = wait_agent({ timeout_ms: 900000 })
+const waitResult = wait_agent({ timeout_ms: 1800000 })  // 30 min
 
 // Drain progress from message bus
 const progressMsgs = mcp__maestro-tools__team_msg({
@@ -184,14 +184,25 @@ for (const msg of (progressMsgs.result?.messages || [])) {
 
 if (waitResult.timed_out) {
   for (const taskId of taskNames) {
-    const lastProgress = (progressMsgs.result?.messages || [])
-      .filter(m => m.data?.task_id === taskId).pop()
-    state.tasks[taskId].status = 'timed_out'
-    state.tasks[taskId].error = lastProgress
-      ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
-      : 'Timed out with no progress reported'
-    close_agent({ target: taskId })
-    delete state.active_agents[taskId]
+    // Status probe before closing
+    followup_task({ target: taskId, message: "STATUS_CHECK: Report current progress, findings so far, and estimated remaining work." })
+    const status = wait_agent({ timeout_ms: 180000 })  // 3 min
+    if (status.timed_out) {
+      followup_task({ target: taskId, message: "FINALIZE: Output all current findings immediately. Time limit reached.", interrupt: true })
+      const forced = wait_agent({ timeout_ms: 180000 })  // 3 min
+      if (forced.timed_out) {
+        const lastProgress = (progressMsgs.result?.messages || [])
+          .filter(m => m.data?.task_id === taskId).pop()
+        state.tasks[taskId].status = 'timed_out'
+        state.tasks[taskId].error = lastProgress
+          ? `Timed out at ${lastProgress.data.phase} (${lastProgress.data.progress_pct}%)`
+          : 'Timed out with no progress reported'
+        close_agent({ target: taskId })
+        delete state.active_agents[taskId]
+      }
+      // else: forced output received, process result
+    }
+    // else: status received, continue processing
   }
 } else {
   // 5) Collect results

package/.codex/skills/team-testing/roles/coordinator/role.md

@@ -166,7 +166,7 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 
 ### Message Semantics
 - **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
-- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+- **followup_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output, and status probing on timeout (STATUS_CHECK / FINALIZE cascade before closing timed-out agents).
 
 ### Agent Lifecycle Management
 - **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.

package/chains/singles/spec-map.json

@@ -12,10 +12,10 @@
   "nodes": {
     "spec_map": {
       "type": "command",
-      "cmd": "spec-map",
+      "cmd": "manage-codebase-rebuild",
       "next": "done",
       "analyze": false,
-      "description": "Analyze codebase with parallel mapper agents to produce codebase documents"
+      "description": "Analyze codebase with parallel mapper agents to produce codebase documents (consolidated into manage-codebase-rebuild)"
     },
     "done": {
       "type": "terminal",

package/dashboard/dist-server/dashboard/src/server/agents/codex-app-server-adapter.d.ts

@@ -26,6 +26,10 @@ export declare class CodexAppServerAdapter extends BaseAgentAdapter {
     private handleLine;
     private handleNotification;
     private classifyItem;
+    /** Get the last assistant message for a process (O(1) without re-parsing JSONL). */
+    getLastMessage(processId: string): string;
+    /** Map codex item type/name to a semantic phase label. */
+    private inferPhase;
     private extractText;
     private setupProcessListeners;
     private cleanup;