oh-my-opencode-slim 2.0.0-beta.14 → 2.0.0-beta.15

package/dist/config/constants.d.ts

@@ -20,7 +20,7 @@ export declare const DEFAULT_TIMEOUT_MS: number;
 export declare const MAX_POLL_TIME_MS: number;
 export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
 export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion or use task_status only when needed \u2192 reconcile terminal results \u2192 verify. Do not consume running-job output or advance dependent work. !END!";
+export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion \u2192 reconcile terminal results \u2192 verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!";
 export declare const WRITABLE_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.\n- Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.\n- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.\n- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
 export declare const READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.\n- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
 export declare const NO_SHELL_READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Use glob/grep/ast_grep_search for discovery and read for file contents.\n- Do not use bash or shell commands.";

package/dist/hooks/phase-reminder/index.d.ts

@@ -1,4 +1,4 @@
-export declare const PHASE_REMINDER = "<internal_reminder>!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion or use task_status only when needed \u2192 reconcile terminal results \u2192 verify. Do not consume running-job output or advance dependent work. !END!</internal_reminder>";
+export declare const PHASE_REMINDER = "<internal_reminder>!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion \u2192 reconcile terminal results \u2192 verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!</internal_reminder>";
 interface MessageInfo {
     role: string;
     agent?: string;

package/dist/index.js

@@ -18321,7 +18321,7 @@ var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion or use task_status only when needed → reconcile terminal results → verify. Do not consume running-job output or advance dependent work. !END!`;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
 var WRITABLE_FILE_OPERATIONS_RULES = `**File Operations Rules**:
 - Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.
 - Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.
@@ -19126,31 +19126,15 @@ ${enabledParallelExamples}
 
 Balance: respect dependencies, avoid parallelizing what must be sequential, and avoid overlapping write ownership.
 
-### OpenCode scheduler model
-- Delegated specialists should be launched as background tasks whenever work can run independently: use \`task(..., background: true)\`.
-- A dispatch returns a task/session ID immediately; it does not mean completion.
-- Track each task ID with specialist, objective, state, and any advisory ownership/dependency labels from the dispatch plan.
-- Background completion is event/hook-driven: when a background task finishes, OpenCode injects a follow-up message with the terminal result.
-- Continue orchestration while tasks run only when useful: planning, scheduling independent lanes, preparing synthesis, or asking needed user questions.
-- If no useful independent work remains, stop after a brief status response; do not call \`task_status\` just to wait. OpenCode will resume you when the background completion event arrives.
-- Use \`task_status(wait: true, timeout_ms: ...)\` only when you actively need a result before a dependent step or final response and no completion event has arrived yet.
-- If \`task_status(wait: true)\` times out and reports the task still \`running\`, the delegated lane is still owned by that specialist. Do not treat the timeout as failure, cancellation, or permission to do the same work yourself.
-- For dependent work, either call \`task_status(wait: true)\` again with the same reasonable interval, or stop with a brief waiting status and let the completion event resume you.
+### Background Task Discipline
+- Prefer \`task(..., background: true)\` for delegated work that can run independently.
+- Track each task's specialist, objective, task/session ID, and file/topic ownership.
+- Continue orchestration only on non-overlapping work; otherwise briefly report what was launched and stop.
+- Before local edits or another writer task, compare against running task scopes.
 - Parallel background tasks are allowed only when their write scopes do not conflict.
-- Final response requires relevant tasks to be terminal and reconciled.
-
-### Background Job Discipline
-- Every background task owns its declared lane until terminal.
-- Do not duplicate, undermine, or race a running lane.
-- A polling timeout is not terminal. The lane remains running until a terminal completion/error/cancel event is observed or the user explicitly cancels it.
-- After dispatch, classify the next step:
-  1. independent: continue,
-  2. dependent: wait/poll,
-  3. no useful independent work: stop and let hook-driven completion resume.
-- Before editing files or spawning another writer, compare against running job scopes.
+- Before final response, reconcile any terminal jobs shown in the Background Job Board.
 - Use \`cancel_task\` only when the user asks, or when a running lane is obsolete, wrong, or conflicts with a safer replacement plan.
 - Cancellation is not rollback: if cancelling a writer, inspect and reconcile partial file changes before launching a replacement lane.
-- Never finalize work that depends on unresolved background jobs.
 
 ### Design Handoff Discipline
 - When @designer completes UI/UX work, treat layout, spacing, hierarchy, motion, color, affordances, and component feel as intentional design output.
@@ -19164,6 +19148,9 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 - When too much unrelated, and really needed, start a fresh session with the specialist
 - If multiple remembered sessions fit, prefer the most recently used matching session.
 - Prefer re-uses over creating new sessions all the time
+- When reusing a specialist session, you MUST pass the existing session or alias in the task tool's \`task_id\` argument. Saying "reuse" in prose is not enough.
+- If the Background Job Board lists \`fix-1 / ses_abc / fixer\`, call task with \`subagent_type: "fixer"\` and \`task_id: "fix-1"\` or \`task_id: "ses_abc"\`.
+- Do not leave \`task_id\` empty when intending to reuse; omitted or empty \`task_id\` creates a new specialist session.
 
 ### Validation routing
 - Validation is a workflow stage owned by the Orchestrator, not a separate specialist
@@ -22640,6 +22627,9 @@ var TRANSIENT_PROCESS_ERROR_TEXT = new Set([
   "Task is not running in this process and has not produced output."
 ]);
 function parseTaskIdFromTaskOutput(output) {
+  const xmlMatch = /<task\s+[^>]*\bid=["']([^"']+)["'][^>]*>/i.exec(output);
+  if (xmlMatch)
+    return xmlMatch[1];
   const lines = output.split(/\r?\n/);
   for (const line of lines) {
     const trimmed = line.trim();
@@ -22674,20 +22664,10 @@ function parseTaskStatusOutput(output) {
     result: parseTaskResultFromOutput(output)
   };
 }
-function classifyTaskStatusOutput(status) {
-  if (status.timedOut)
-    return "timeout";
-  if (status.state === "running")
-    return "running";
-  if (status.state === "completed" || status.state === "cancelled") {
-    return "terminal";
-  }
-  if (TRANSIENT_PROCESS_ERROR_TEXT.has(status.result ?? "")) {
-    return "transient_process_error";
-  }
-  return "unknown_error";
-}
 function parseTaskStateFromOutput(output) {
+  const xmlMatch = /<task\s+[^>]*\bstate=["'](running|completed|error|cancelled)["'][^>]*>/i.exec(output);
+  if (xmlMatch)
+    return xmlMatch[1].toLowerCase();
   for (const line of getTaskHeader(output).split(/\r?\n/)) {
     const match = /^state:\s*(running|completed|error|cancelled)\s*$/i.exec(line.trim());
     if (match)
@@ -22823,7 +22803,7 @@ class BackgroundJobBoard {
     if (!existing)
       return;
     const isStaleTerminal = TERMINAL_STATES.has(existing.state) || existing.state === "reconciled";
-    if (!isStaleTerminal || existing.cancellationRequested) {
+    if (isStaleTerminal) {
       const updated2 = {
         ...existing,
         lastLiveBusyAt: now
@@ -22833,17 +22813,8 @@ class BackgroundJobBoard {
     }
     const updated = {
       ...existing,
-      state: "running",
-      timedOut: false,
-      statusUncertain: false,
-      cancellationRequested: false,
-      terminalUnreconciled: false,
       updatedAt: now,
-      lastLiveBusyAt: now,
-      completedAt: undefined,
-      terminalState: undefined,
-      resultSummary: undefined,
-      lastStatusError: undefined
+      lastLiveBusyAt: now
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -22902,9 +22873,6 @@ class BackgroundJobBoard {
     const value = taskIDOrAlias.trim();
     return this.list(parentSessionID).find((job) => job.taskID === value || job.alias === value);
   }
-  resolveForStatus(parentSessionID, taskIDOrAlias) {
-    return this.resolve(parentSessionID, taskIDOrAlias);
-  }
   resolveReusable(parentSessionID, taskIDOrAlias, agent) {
     const job = this.resolve(parentSessionID, taskIDOrAlias);
     if (!job || !isReusable(job))
@@ -22960,7 +22928,7 @@ class BackgroundJobBoard {
     return [
       "### Background Job Board",
       "SENTINEL: background-job-board-v2",
-      "Use task_status for running jobs. Reconcile terminal jobs before final response. Reuse only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
+      "Do not poll running jobs. Wait for hook-driven completion, or use cancel_task only for explicit cancellation. Reconcile terminal jobs before final response. Reuse only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
       "",
       "#### Active / Unreconciled",
       ...active.length > 0 ? active.map((job) => formatJob(job, now)) : ["- none"],
@@ -23223,7 +23191,7 @@ function activationPrompt(task2) {
     "- draft a plan and get `@oracle` review before implementation;",
     "- create and review a phased implementation/delegation plan;",
     "- execute phase by phase with background specialists where useful;",
-    "- poll `task_status`, reconcile results, validate, and ask `@oracle` to review each phase;",
+    "- wait for hook-driven background completion, reconcile results, validate, and ask `@oracle` to review each phase;",
     "- ask `@oracle` to include simplify/readability feedback in phase reviews;",
     "- fix actionable review issues before continuing.",
     "",
@@ -24001,6 +23969,7 @@ var BACKGROUND_JOB_BOARD_SENTINEL = "SENTINEL: background-job-board-v2";
 var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
 var BACKGROUND_COMPLETION_FAILED = /^Background task failed: /;
 var MAX_PROCESSED_INJECTED_COMPLETIONS = 500;
+var RAW_SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
 function djb2Hash(str) {
   let hash = 5381;
   for (let i = 0;i < str.length; i++) {
@@ -24035,6 +24004,10 @@ function isObjectRecord(value) {
 function extractPath(output) {
   return /<path>([^<]+)<\/path>/.exec(output)?.[1];
 }
+function extractTaskSummary(output) {
+  const summary = /<summary>\s*([\s\S]*?)\s*<\/summary>/i.exec(output)?.[1];
+  return summary?.trim() || undefined;
+}
 function normalizePath(root, file) {
   const relative = path9.relative(root, file);
   if (!relative || relative.startsWith("..") || path9.isAbsolute(relative)) {
@@ -24126,7 +24099,7 @@ function createTaskSessionManagerHook(_ctx, options) {
     const status = parseTaskStatusOutput(output);
     if (!status)
       return;
-    log("[task-session-manager] parsed task status output", {
+    log("[task-session-manager] parsed task output status", {
       taskID: status.taskID,
       state: status.state,
       timedOut: status.timedOut,
@@ -24171,73 +24144,23 @@ function createTaskSessionManagerHook(_ctx, options) {
     }
     return updated;
   }
-  async function handleTransientTaskStatusOutput(output) {
-    if (typeof output.output !== "string")
-      return false;
-    const status = parseTaskStatusOutput(output.output);
-    if (!status)
-      return false;
-    if (classifyTaskStatusOutput(status) !== "transient_process_error") {
-      return false;
-    }
-    const existing = backgroundJobBoard.get(status.taskID);
-    const liveStatus = existing && existing.state === "running" ? undefined : await getLiveSessionStatus(status.taskID);
-    const recentLiveBusy = !!existing?.lastLiveBusyAt && (!existing.completedAt || existing.lastLiveBusyAt >= existing.completedAt);
-    const isStillRunning = existing?.state === "running" || recentLiveBusy || liveStatus === "busy" || liveStatus === "retry";
-    if (!isStillRunning)
-      return false;
-    const updated = existing?.state === "running" ? backgroundJobBoard.updateStatus({
-      taskID: status.taskID,
-      state: "running",
-      statusUncertain: true,
-      lastStatusError: status.result
-    }) : undefined;
-    log("[task-session-manager] classified transient task_status error", {
-      taskID: status.taskID,
-      alias: existing?.alias,
-      parentSessionID: existing?.parentSessionID,
-      previousState: existing?.state,
-      updatedState: updated?.state,
-      liveStatus,
-      recentLiveBusy
-    });
-    return true;
-  }
-  async function getLiveSessionStatus(sessionID) {
-    try {
-      const response = await _ctx.client.session.status();
-      const data = response.data;
-      if (!isObjectRecord(data))
-        return;
-      const item = data[sessionID];
-      if (item === undefined)
-        return "idle";
-      if (isObjectRecord(item) && typeof item.type === "string") {
-        return item.type;
-      }
-      const directType = data.type;
-      if (typeof directType === "string")
-        return directType;
-      const nestedStatus = data.status;
-      if (!isObjectRecord(nestedStatus))
-        return;
-      return typeof nestedStatus.type === "string" ? nestedStatus.type : undefined;
-    } catch {
-      return;
-    }
-  }
   function updateFromInjectedCompletion(part, message, _messageIndex, partIndex) {
     if (part.type !== "text" || typeof part.text !== "string") {
       return;
     }
-    const isCompleted = BACKGROUND_COMPLETION_COMPLETED.test(part.text);
-    const isFailed = BACKGROUND_COMPLETION_FAILED.test(part.text);
-    if (part.synthetic !== true || !isCompleted && !isFailed) {
+    if (part.synthetic !== true)
       return;
-    }
     const status = parseTaskStatusOutput(part.text);
     if (!status)
       return;
+    if (status.state !== "completed" && status.state !== "error") {
+      return;
+    }
+    const summary = extractTaskSummary(part.text);
+    const isCompleted = summary ? BACKGROUND_COMPLETION_COMPLETED.test(summary) : status.state === "completed";
+    const isFailed = summary ? BACKGROUND_COMPLETION_FAILED.test(summary) : status.state === "error";
+    if (summary && !isCompleted && !isFailed)
+      return;
     const occurrenceId = createOccurrenceId(part, message, partIndex);
     const existing = backgroundJobBoard.get(status.taskID);
     if (isFailed && isLateCancelledTaskError(existing, status.state)) {
@@ -24350,23 +24273,13 @@ function createTaskSessionManagerHook(_ctx, options) {
   return {
     "tool.execute.before": async (input, output) => {
       const toolName = input.tool.toLowerCase();
-      if (toolName !== "task" && toolName !== "task_status")
+      if (toolName !== "task")
         return;
       if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
         return;
       }
       if (!isObjectRecord(output.args))
         return;
-      if (toolName === "task_status") {
-        const args2 = output.args;
-        if (typeof args2.task_id !== "string" || args2.task_id.trim() === "") {
-          return;
-        }
-        const resolved = backgroundJobBoard.resolveForStatus(input.sessionID, args2.task_id.trim());
-        if (resolved)
-          args2.task_id = resolved.taskID;
-        return;
-      }
       const args = output.args;
       if (!isAgentName(args.subagent_type)) {
         if (typeof args.task_id === "string" && args.task_id.trim() !== "") {
@@ -24395,6 +24308,11 @@ function createTaskSessionManagerHook(_ctx, options) {
       const requested = args.task_id.trim();
       const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, args.subagent_type);
       if (!remembered) {
+        if (RAW_SESSION_ID_PATTERN.test(requested)) {
+          pendingCall.resumedTaskId = requested;
+          rememberPendingCall(pendingCall);
+          return;
+        }
         delete args.task_id;
         return;
       }
@@ -24411,24 +24329,13 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
-      if (input.tool.toLowerCase() === "task_status") {
-        if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
-          return;
-        }
-        normalizeLateCancelledToolStatus(output);
-        if (await handleTransientTaskStatusOutput(output)) {
-          return;
-        }
-        updateBackgroundJobFromOutput(output.output);
-        return;
-      }
       if (input.tool.toLowerCase() !== "task")
         return;
       const pending = takePendingCall(input.callID, input.sessionID);
       if (!pending || typeof output.output !== "string")
         return;
       const launch = parseTaskLaunchOutput(output.output);
-      if (launch) {
+      if (launch && !launch.result?.match(/Timed out after \d+ms/i)) {
         const record = backgroundJobBoard.registerLaunch({
           taskID: launch.taskID,
           parentSessionID: pending.parentSessionId,
@@ -24448,6 +24355,39 @@ function createTaskSessionManagerHook(_ctx, options) {
         pendingManagedTaskIds.add(launch.taskID);
         return;
       }
+      normalizeLateCancelledTaskOutput(output);
+      const status = parseTaskStatusOutput(output.output);
+      if (status) {
+        const existing = backgroundJobBoard.get(status.taskID);
+        const record = existing ?? backgroundJobBoard.registerLaunch({
+          taskID: status.taskID,
+          parentSessionID: pending.parentSessionId,
+          agent: pending.agentType,
+          description: pending.label,
+          objective: pending.label
+        });
+        const updated = backgroundJobBoard.updateStatus({
+          taskID: status.taskID,
+          state: status.state,
+          timedOut: status.timedOut,
+          resultSummary: status.result
+        });
+        log("[task-session-manager] foreground task status registered", {
+          taskID: status.taskID,
+          alias: updated?.alias ?? record.alias,
+          parentSessionID: pending.parentSessionId,
+          agent: pending.agentType,
+          state: updated?.state ?? record.state
+        });
+        if (pending.resumedTaskId && pending.resumedTaskId !== status.taskID) {
+          backgroundJobBoard.drop(pending.resumedTaskId);
+        }
+        pendingManagedTaskIds.delete(status.taskID);
+        const contextFiles2 = contextFilesForPrompt(contextByTask.get(status.taskID));
+        backgroundJobBoard.addContext(status.taskID, contextFiles2);
+        pruneContext();
+        return;
+      }
       const taskId = parseTaskIdFromTaskOutput(output.output);
       if (!taskId) {
         if (pending.resumedTaskId && isMissingRememberedSessionError(output.output)) {
@@ -24595,7 +24535,7 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     }
   };
-  function normalizeLateCancelledToolStatus(output) {
+  function normalizeLateCancelledTaskOutput(output) {
     if (typeof output.output !== "string")
       return;
     const status = parseTaskStatusOutput(output.output);
@@ -24604,7 +24544,7 @@ function createTaskSessionManagerHook(_ctx, options) {
     const existing = backgroundJobBoard.get(status.taskID);
     if (!isLateCancelledTaskError(existing, status.state))
       return;
-    log("[task-session-manager] normalized late cancelled task_status output", {
+    log("[task-session-manager] normalized late cancelled task output", {
       taskID: status.taskID,
       alias: existing?.alias,
       state: existing?.state,

package/dist/tui.js

@@ -68,7 +68,7 @@ var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion or use task_status only when needed → reconcile terminal results → verify. Do not consume running-job output or advance dependent work. !END!`;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
 var WRITABLE_FILE_OPERATIONS_RULES = `**File Operations Rules**:
 - Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.
 - Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.

package/dist/utils/background-job-board.d.ts

@@ -68,7 +68,6 @@ export declare class BackgroundJobBoard {
     }): BackgroundJobRecord | undefined;
     get(taskID: string): BackgroundJobRecord | undefined;
     resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
-    resolveForStatus(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
     resolveReusable(parentSessionID: string, taskIDOrAlias: string, agent?: string): BackgroundJobRecord | undefined;
     markUsed(parentSessionID: string, key: string, now?: number): void;
     taskIDs(): Set<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "2.0.0-beta.14",
+  "version": "2.0.0-beta.15",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/skills/deepwork/SKILL.md

@@ -104,8 +104,8 @@ Use the scheduler model throughout:
 
 - follow Orchestrator delegations rules
 - record task/session IDs and ownership boundaries;
-- poll `task_status` before consuming background results;
-- avoid blocking Orchestrator lane too long; prefer shorter periodic task waits
-  rather than one long wait;
+- wait for hook-driven background completion before consuming background results;
+- avoid blocking Orchestrator lane while background jobs run; if no independent
+  work remains, stop briefly and let the completion event resume the workflow;
 - do not advance to the next phase while relevant jobs are running or terminal
   results are unreconciled.