oh-my-opencode-slim 1.1.1 → 2.0.0-beta.0

package/dist/index.js

@@ -18230,19 +18230,6 @@ var CUSTOM_SKILLS = [
 ];
 
 // src/cli/skills.ts
-var RECOMMENDED_SKILLS = [
-  {
-    name: "agent-browser",
-    repo: "https://github.com/vercel-labs/agent-browser",
-    skillName: "agent-browser",
-    allowedAgents: ["designer"],
-    description: "High-performance browser automation",
-    postInstallCommands: [
-      "npm install -g agent-browser",
-      "agent-browser install"
-    ]
-  }
-];
 var PERMISSION_ONLY_SKILLS = [
   {
     name: "requesting-code-review",
@@ -18267,12 +18254,6 @@ function getSkillPermissionsForAgent(agentName, skillList) {
     }
     return permissions;
   }
-  for (const skill of RECOMMENDED_SKILLS) {
-    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
-      permissions[skill.skillName] = "allow";
-    }
-  }
   for (const skill of CUSTOM_SKILLS) {
     const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
     if (isAllowed) {
@@ -18322,8 +18303,8 @@ 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! Recall the workflow rules:
-Understand → choose the best parallelized path based on your capabilities and agents delegation rules → recall session reuse rules → execute → verify.
-If delegating, launch the specialist in the same turn you mention it !END!`;
+Understand → build a short work graph with independent lanes, dependencies, and advisory ownership → dispatch independent specialists as background tasks → record task/session IDs → continue orchestration → poll task_status for terminal results → reconcile → verify.
+Only consume outputs or advance dependent work when background results are terminal. !END!`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
 var DEFAULT_DISABLED_AGENTS = ["observer"];
@@ -18670,7 +18651,9 @@ function loadConfigFromPath(configPath, options) {
     const content = fs.readFileSync(configPath, "utf-8");
     let rawConfig;
     try {
-      rawConfig = JSON.parse(stripJsonComments(content));
+      const stripped = stripJsonComments(content);
+      const interpolated = stripped.replace(/\{env:([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
+      rawConfig = JSON.parse(interpolated);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       options?.onWarning?.({
@@ -18977,6 +18960,7 @@ ${customAppendPrompt}`;
 }
 var AGENT_DESCRIPTIONS = {
   explorer: `@explorer
+- Lane: Codebase discovery and reconnaissance
 - Role: Parallel search specialist for discovering unknowns across the codebase
 - Permissions: Read files
 - Stats: 2x faster codebase search than orchestrator, 1/2 cost of orchestrator
@@ -18984,38 +18968,43 @@ var AGENT_DESCRIPTIONS = {
 - **Delegate when:** Need to discover what exists before planning • Parallel searches speed discovery • Need summarized map vs full contents • Broad/uncertain scope
 - **Don't delegate when:** Know the path and need actual content • Need full file anyway • Single specific lookup • About to edit the file`,
   librarian: `@librarian
+- Lane: External knowledge and library research
 - Role: Authoritative source for current library docs and API references
 - Permissions: External docs/search MCPs; no file edits
 - Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
 - Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
 - **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) • Complex APIs needing official examples (ORMs, auth) • Version-specific behavior matters • Unfamiliar library • Edge cases or advanced features • Nuanced best practices
 - **Don't delegate when:** Standard usage you're confident • Simple stable APIs • General programming knowledge • Info already in conversation • Built-in language features
-- **Rule of thumb:** "How does this library work?" → @librarian. "How does programming work?" → yourself.`,
+- **Rule of thumb:** "How does this library work?" → @librarian. "How does programming work?" → answer directly.`,
   oracle: `@oracle
+- Lane: Architecture, risk, debugging strategy, and review
 - Role: Strategic advisor for high-stakes decisions and persistent problems, code reviewer
 - Permissions: Read files
 - Stats: 5x better decision maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
 - Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging, code review, simplification, maintainability review
 - **Delegate when:** Major architectural decisions with long-term impact • Problems persisting after 2+ fix attempts • High-risk multi-system refactors • Costly trade-offs (performance vs maintainability) • Complex debugging with unclear root cause • Security/scalability/data integrity decisions • Genuinely uncertain and cost of wrong choice is high • When a workflow calls for a **reviewer** subagent • Code needs simplification or YAGNI scrutiny
 - **Don't delegate when:** Routine decisions you're confident about • First bug fix attempt • Straightforward trade-offs • Tactical "how" vs strategic "should" • Time-sensitive good-enough decisions • Quick research/testing can answer
-- **Rule of thumb:** Need senior architect review? → @oracle. Need code review or simplification? → @oracle. Just do it and PR? → yourself.`,
+- **Rule of thumb:** Need senior architect review? → @oracle. Need code review or simplification? → @oracle. Routine coordination or final synthesis? → handle directly.`,
   designer: `@designer
+- Lane: User-facing UI/UX design, polish, and review
 - Role: UI/UX specialist for intentional, polished experiences
 - Permissions: Read/write files
 - Stats: 10x better UI/UX than orchestrator
 - Capabilities: Visual relevant edits, interactions, responsive layouts, design systems with aesthetic intent, deep UI/UX knowledge.
 - **Delegate when:** User-facing interfaces needing polish • Responsive layouts • UX-critical components (forms, nav, dashboards) • Visual consistency systems • Animations/micro-interactions • Landing/marketing pages • Refining functional→delightful • Reviewing existing UI/UX quality
 - **Don't delegate when:** Backend/logic with no visual • Quick prototypes where design doesn't matter yet
-- **Rule of thumb:** Users see it and polish matters? → @designer. Headless/functional? → yourself.`,
+- **Rule of thumb:** Users see it and polish matters? → @designer. Headless/functional implementation? → schedule @fixer.`,
   fixer: `@fixer
+- Lane: Bounded implementation and test execution
 - Role: Fast execution specialist for well-defined tasks, which empowers orchestrator with parallel, speedy executions
 - Permissions: Read/write files
 - Stats: 2x faster code edits, 1/2 cost of orchestrator, 0.8x quality of orchestrator
 - Tools/Constraints: Execution-focused—no research, no architectural decisions
 - **Delegate when:** For implementation work, think and triage first. If the change is non-trivial or multi-file, hand bounded execution to @fixer • Writing or updating tests • Tasks that touch test files, fixtures, mocks, or test helpers. Parallelization benefits: Task involves multiple folders and multiple files modificaiton, scoping work per folder and spawning parallel @fixers for each folder.
 - **Don't delegate when:** Needs discovery/research/decisions • Single small change (<20 lines, one file) • Unclear requirements needing iteration • Explaining to fixer > doing • Tight integration with your current work • Sequential dependencies
-- **Rule of thumb:** Explaining > doing? → yourself. Test file modifications and bounded implementation work usually go to @fixer. Bigger or lots of edits, splitting makes sense, parallelized by spawning @fixers per certain scope.`,
+- **Rule of thumb:** If implementation or tests are needed, schedule @fixer with clear scope. Bigger or lots of edits should be split by ownership and dispatched as parallel background fixer lanes when safe.`,
   council: `@council
+- Lane: High-stakes multi-model decision support
 - Role: Multi-LLM consensus engine that runs several councillors, synthesizes their views, and returns a structured council report.
 - Permissions: Read files
 - Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
@@ -19024,15 +19013,16 @@ var AGENT_DESCRIPTIONS = {
 - **Don't delegate when:** Straightforward tasks you're confident about • Speed matters more than confidence • Routine implementation/debugging • A single specialist is clearly the right tool • You only need current docs/search/code review rather than multi-model consensus.
 - **How to call:** Send the full question/task and relevant context. Be explicit about what decision, trade-off, or answer the council should resolve. Do not ask council to do routine code edits.
 - **Result handling:** Council returns a structured response that may include: synthesized Council Response, individual Councillor Details, and Council Summary/confidence. Preserve that structure when the user asked for council output. Do not pretend the council only returned a final answer. If you need to act on the council result, first briefly state the council's recommendation, then proceed.
-- **Rule of thumb:** Need second/third opinions from different models? → @council. Need one expert agent or direct execution? → use the specialist or yourself.`,
+- **Rule of thumb:** Need second/third opinions from different models? → @council. Need one expert lane? → use the specialist. Need final synthesis? → handle directly.`,
   observer: `@observer
+- Lane: Visual/media analysis isolated from orchestrator context
 - Role: Visual analysis specialist for images, PDFs, and diagrams
 - Permissions: Read files
 - Stats: Saves main context tokens — Observer processes raw files, returns structured observations
 - Capabilities: Interprets images, screenshots, PDFs, and diagrams via native read tool; extracts UI elements, layouts, text, relationships
 - **Delegate when:** Need to analyze a multimedia file• Extract information
 - **Don't delegate when:** Plain text files that Read can handle directly • Files that need editing afterward (need literal content from Read)
-- **Rule of thumb:** Even if your model supports vision, delegate visual analysis to @observer — it isolates large image/PDF bytes from your context window, returning only concise structured text. Need exact file contents for editing? → Read it yourself.
+- **Rule of thumb:** Even if your model supports vision, delegate visual analysis to @observer — it isolates large image/PDF bytes from your context window, returning only concise structured text. Need exact file contents for routing? → Read only the minimal context yourself.
 - **IMPORTANT:** When delegating to @observer, always include the **full file path** in the prompt so it can read the file. Example: "Analyze the screenshot at /path/to/file.png — describe the UI elements and error messages."`
 };
 var VALIDATION_ROUTING = [
@@ -19067,7 +19057,9 @@ function buildOrchestratorPrompt(disabledAgents) {
   }).join(`
 `);
   return `<Role>
-You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
+You are a workflow manager for coding work. Your job is to plan, schedule, delegate, monitor, reconcile, and verify specialist-agent work. You are not the default implementation worker.
+
+Optimize for quality, speed, cost, and reliability by dispatching the right specialist lanes, tracking background task state, and integrating terminal results into one coherent outcome.
 </Role>
 
 <Agents>
@@ -19085,22 +19077,31 @@ Parse request: explicit requirements + implicit needs.
 Evaluate approach by: quality, speed, cost, reliability.
 Choose the path that optimizes all four.
 
+Classify work into lanes: discovery, external knowledge, implementation, UI/UX, review/risk, visual analysis, and final verification.
+
 ## 3. Delegation Check
 **STOP. Review specialists before acting.**
 
-!!! Review available agents and delegation rules. Decide whether to delegate or do it yourself. !!!
+!!! Review available agents and lane rules. Decide what to schedule, what depends on what, and what minimal direct coordination is needed. !!!
 
-**Delegation efficiency:**
+**Dispatch efficiency:**
 - Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
 - Provide context summaries, let specialists read what they need
 - Brief user on delegation goal before each call
-- Skip delegation if overhead ≥ doing it yourself
+- Keep direct work limited to clarification, minimal routing context, todos, synthesis, and final checks
+- For trivial conversational answers or tiny mechanical edits, direct execution is allowed when scheduling overhead would clearly dominate
 
-## 4. Split and Parallelize
-Can tasks be split into subtasks and run in parallel?
+## 4. Plan and Parallelize
+Build a short work graph before dispatching:
+- Independent lanes that can run now
+- Dependency-ordered lanes that must wait
+- Advisory ownership for write-capable lanes
+- Verification/review lanes that run after implementation
+
+Can tasks be split into background specialist work?
 ${enabledParallelExamples}
 
-Balance: respect dependencies, avoid parallelizing what must be sequential.
+Balance: respect dependencies, avoid parallelizing what must be sequential, and avoid overlapping write ownership.
 
 ### Context Isolation
 If no specialist delegation is needed, consider \`subtask\` before doing
@@ -19113,6 +19114,8 @@ compact outcome.
 Use \`subtask\` for focused investigation, bounded analysis, cleanup, or
 verification across files/logs/messages.
 
+Prefer native background \`task(..., background: true)\` plus \`task_status\` for independent specialist lanes. Use \`subtask\` only for bounded parent-local context isolation when native background specialist scheduling is not the right fit.
+
 Do not use \`subtask\` for tiny tasks, open-ended work, interactive decisions,
 work better handled by a named specialist, or cases where the parent must reason
 over the details.
@@ -19121,21 +19124,28 @@ When calling \`subtask\`, give a self-contained prompt with objective,
 constraints, relevant context, deliverable, and validation. Pass only clearly
 relevant files. Wait for the summary, then integrate and verify it.
 
-### OpenCode subagent execution model
-- A delegated specialist runs in a separate child session.
-- Delegation is blocking for the parent at that point: send work out, then continue that line after results return.
-- Parallel delegation means launching multiple independent child-session branches.
-- Only parallelize branches that are truly independent; reconcile dependent steps after delegated results come back.
-
-## 5. Execute
-1. Break complex tasks into todos
-2. Fire parallel research/implementation
-3. Delegate to specialists or do it yourself based on step 3
-4. Integrate results
-5. Adjust if needed
+### 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.
+- Continue orchestration while tasks run: planning, scheduling independent lanes, preparing synthesis, and asking needed user questions.
+- Poll or wait with \`task_status(wait: true, timeout_ms: ...)\` before consuming outputs or starting dependent work.
+- Parallel background tasks are allowed only when their write scopes do not conflict.
+- Final response requires relevant tasks to be terminal and reconciled.
+
+## 5. Dispatch
+1. Split work into independent and dependency-ordered lanes
+2. Plan advisory ownership for write-capable lanes
+3. Dispatch independent specialists as background tasks
+4. Record task IDs, state, and advisory ownership/dependency labels
+5. Continue only independent orchestration while jobs run
+6. Poll/wait for terminal results with \`task_status(wait: true, timeout_ms: ...)\`
+7. Reconcile results, resolve conflicts, and gate dependent lanes
+8. Dispatch follow-up jobs if needed
+9. Verify final state
 
 ### Session Reuse
-- Smartly reuse an available specialist session - constext reuse saves time and tokens
+- Smartly reuse an available specialist session - context reuse saves time and tokens
 - 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
@@ -19187,7 +19197,7 @@ When user's approach seems problematic:
 **Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
 
 **Good:** "Checking Next.js App Router docs via @librarian..."
-[proceeds with implementation]
+[continues scheduling or integration]
 
 </Communication>
 `;
@@ -22600,6 +22610,221 @@ function createDisplayNameMentionRewriter(config) {
     return rewritten;
   };
 }
+// src/utils/task.ts
+function parseTaskIdFromTaskOutput(output) {
+  const lines = output.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = /^task_id:\s*([^\s()]+)(?:\s*\(.*)?$/.exec(trimmed);
+    if (!match) {
+      continue;
+    }
+    return match[1];
+  }
+  return;
+}
+function parseTaskLaunchOutput(output) {
+  const taskID = parseTaskIdFromTaskOutput(output);
+  const state = parseTaskStateFromOutput(output);
+  if (!taskID || state !== "running")
+    return;
+  return {
+    taskID,
+    state,
+    result: parseTaskResultFromOutput(output)
+  };
+}
+function parseTaskStatusOutput(output) {
+  const taskID = parseTaskIdFromTaskOutput(output);
+  const state = parseTaskStateFromOutput(output);
+  if (!taskID || !state)
+    return;
+  return {
+    taskID,
+    state,
+    timedOut: state === "running" && /Timed out after \d+ms/i.test(output),
+    result: parseTaskResultFromOutput(output)
+  };
+}
+function parseTaskStateFromOutput(output) {
+  for (const line of getTaskHeader(output).split(/\r?\n/)) {
+    const match = /^state:\s*(running|completed|error|cancelled)\s*$/i.exec(line.trim());
+    if (match)
+      return match[1].toLowerCase();
+  }
+  return;
+}
+function parseTaskResultFromOutput(output) {
+  const match = /<task_(result|error)>\s*([\s\S]*?)\s*<\/task_\1>/m.exec(output);
+  const result = match?.[2]?.trim();
+  return result || undefined;
+}
+function getTaskHeader(output) {
+  const resultIndex = output.search(/<task_(?:result|error)>/);
+  if (resultIndex === -1)
+    return output;
+  return output.slice(0, resultIndex);
+}
+
+// src/utils/background-job-board.ts
+var TERMINAL_STATES = new Set([
+  "completed",
+  "error",
+  "cancelled"
+]);
+var AGENT_PREFIX = {
+  council: "cou",
+  designer: "des",
+  explorer: "exp",
+  fixer: "fix",
+  librarian: "lib",
+  observer: "obs",
+  oracle: "ora"
+};
+
+class BackgroundJobBoard {
+  jobs = new Map;
+  counters = new Map;
+  registerLaunch(input) {
+    const now = input.now ?? Date.now();
+    const existing = this.jobs.get(input.taskID);
+    if (existing) {
+      const updated = {
+        ...existing,
+        agent: input.agent || existing.agent,
+        description: input.description || existing.description,
+        objective: input.objective ?? existing.objective,
+        state: "running",
+        timedOut: false,
+        terminalUnreconciled: false,
+        completedAt: undefined,
+        resultSummary: undefined,
+        updatedAt: now
+      };
+      this.jobs.set(input.taskID, updated);
+      return updated;
+    }
+    const record = {
+      taskID: input.taskID,
+      parentSessionID: input.parentSessionID,
+      agent: input.agent,
+      description: input.description || `background ${input.agent} task`,
+      objective: input.objective,
+      state: "running",
+      timedOut: false,
+      terminalUnreconciled: false,
+      launchedAt: now,
+      updatedAt: now,
+      alias: this.nextAlias(input.parentSessionID, input.agent)
+    };
+    this.jobs.set(input.taskID, record);
+    return record;
+  }
+  updateStatus(input) {
+    const existing = this.jobs.get(input.taskID);
+    if (!existing)
+      return;
+    const now = input.now ?? Date.now();
+    const terminal = TERMINAL_STATES.has(input.state);
+    const updated = {
+      ...existing,
+      state: input.state,
+      timedOut: input.timedOut ?? false,
+      terminalUnreconciled: terminal ? true : existing.terminalUnreconciled,
+      updatedAt: now,
+      completedAt: terminal ? existing.completedAt ?? now : existing.completedAt,
+      resultSummary: input.resultSummary ?? existing.resultSummary
+    };
+    this.jobs.set(input.taskID, updated);
+    return updated;
+  }
+  updateFromStatusOutput(output) {
+    const status = parseTaskStatusOutput(output);
+    if (!status)
+      return;
+    return this.updateStatus({
+      taskID: status.taskID,
+      state: status.state,
+      timedOut: status.timedOut,
+      resultSummary: status.result
+    });
+  }
+  markReconciled(taskID, now = Date.now()) {
+    const existing = this.jobs.get(taskID);
+    if (!existing)
+      return;
+    if (!existing.terminalUnreconciled && !TERMINAL_STATES.has(existing.state)) {
+      return;
+    }
+    const updated = {
+      ...existing,
+      state: "reconciled",
+      terminalUnreconciled: false,
+      updatedAt: now
+    };
+    this.jobs.set(taskID, updated);
+    return updated;
+  }
+  get(taskID) {
+    return this.jobs.get(taskID);
+  }
+  list(parentSessionID) {
+    const jobs = [...this.jobs.values()];
+    const filtered = parentSessionID ? jobs.filter((job) => job.parentSessionID === parentSessionID) : jobs;
+    return filtered.sort((a, b) => a.launchedAt - b.launchedAt);
+  }
+  hasRunning(parentSessionID) {
+    return this.list(parentSessionID).some((job) => job.state === "running");
+  }
+  hasTerminalUnreconciled(parentSessionID) {
+    return this.list(parentSessionID).some((job) => job.terminalUnreconciled);
+  }
+  formatForPrompt(parentSessionID) {
+    const jobs = this.list(parentSessionID).filter((job) => job.state === "running" || job.terminalUnreconciled);
+    if (jobs.length === 0)
+      return;
+    return [
+      "### Background Job Board",
+      "Use task_status before consuming running jobs. Reconcile terminal jobs before final response.",
+      "",
+      ...jobs.map(formatJob)
+    ].join(`
+`);
+  }
+  clearParent(parentSessionID) {
+    for (const job of this.list(parentSessionID)) {
+      this.jobs.delete(job.taskID);
+    }
+  }
+  drop(taskID) {
+    this.jobs.delete(taskID);
+  }
+  nextAlias(parentSessionID, agent) {
+    const prefix2 = AGENT_PREFIX[agent] ?? (agent.slice(0, 3) || "job");
+    const key = `${parentSessionID}:${prefix2}`;
+    const next = (this.counters.get(key) ?? 0) + 1;
+    this.counters.set(key, next);
+    return `${prefix2}-${next}`;
+  }
+}
+function formatJob(job) {
+  const status = job.terminalUnreconciled ? `${job.state}, unreconciled` : job.timedOut ? `${job.state}, timed out` : job.state;
+  const lines = [
+    `- ${job.alias} / ${job.taskID} / ${job.agent} / ${status}`,
+    `  Objective: ${job.objective || job.description}`
+  ];
+  if (job.resultSummary && job.terminalUnreconciled) {
+    lines.push(`  Result: ${singleLine(job.resultSummary)}`);
+  }
+  return lines.join(`
+`);
+}
+function singleLine(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= 160)
+    return normalized;
+  return `${normalized.slice(0, 157)}...`;
+}
 // src/utils/internal-initiator.ts
 var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
 function isRecord(value) {
@@ -22851,19 +23076,6 @@ function formatContextFiles(files, options) {
   const rendered = shown.map((file) => `${file.path} (${file.lineCount} lines)`);
   return `${rendered.join(", ")}${rest > 0 ? ` (+${rest} more)` : ""}`;
 }
-// src/utils/task.ts
-function parseTaskIdFromTaskOutput(output) {
-  const lines = output.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const match = /^task_id:\s*([^\s()]+)(?:\s*\(.*)?$/.exec(trimmed);
-    if (!match) {
-      continue;
-    }
-    return match[1];
-  }
-  return;
-}
 // src/utils/zip-extractor.ts
 import { spawnSync } from "node:child_process";
 import { release } from "node:os";
@@ -23677,14 +23889,13 @@ function createPhaseReminderHook() {
       if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
         return;
       }
-      if (originalText.includes(PHASE_REMINDER)) {
+      if (lastUserMessage.parts.some((p) => p.text?.includes(PHASE_REMINDER))) {
         return;
       }
-      lastUserMessage.parts[textPartIndex].text = `${originalText}
-
----
-
-${PHASE_REMINDER}`;
+      lastUserMessage.parts.push({
+        type: "text",
+        text: PHASE_REMINDER
+      });
     }
   };
 }
@@ -24066,6 +24277,9 @@ var AGENT_NAME_SET = new Set([
 var MAX_PENDING_TASK_CALLS = 100;
 var RESUMABLE_SESSIONS_START = "<resumable_sessions>";
 var RESUMABLE_SESSIONS_END = "</resumable_sessions>";
+var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
+var BACKGROUND_COMPLETION_FAILED = /^Background task failed: /;
+var MAX_PROCESSED_INJECTED_COMPLETIONS = 500;
 function isAgentName(value) {
   return typeof value === "string" && AGENT_NAME_SET.has(value);
 }
@@ -24109,10 +24323,14 @@ function createTaskSessionManagerHook(_ctx, options) {
     readContextMinLines: options.readContextMinLines,
     readContextMaxFiles: options.readContextMaxFiles
   });
+  const backgroundJobBoard = options.backgroundJobBoard ?? new BackgroundJobBoard;
   const pendingCalls = new Map;
   const pendingCallOrder = [];
   const contextByTask = new Map;
   const pendingManagedTaskIds = new Set;
+  const terminalJobsInjectedByParent = new Map;
+  const processedInjectedCompletions = new Set;
+  const processedInjectedCompletionOrder = [];
   let anonymousPendingCallId = 0;
   function addTaskContext(taskId, files) {
     if (files.length === 0)
@@ -24156,6 +24374,62 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     }
   }
+  function updateBackgroundJobFromOutput(output) {
+    if (typeof output !== "string")
+      return;
+    const status = parseTaskStatusOutput(output);
+    if (!status)
+      return;
+    const updated = backgroundJobBoard.updateStatus({
+      taskID: status.taskID,
+      state: status.state,
+      timedOut: status.timedOut,
+      resultSummary: status.result
+    });
+    if (!updated)
+      return;
+    if (updated.terminalUnreconciled) {
+      pendingManagedTaskIds.delete(updated.taskID);
+      contextByTask.delete(updated.taskID);
+      pruneContext();
+    }
+    return updated;
+  }
+  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) {
+      return;
+    }
+    const status = parseTaskStatusOutput(part.text);
+    if (!status)
+      return;
+    if (isCompleted && status.state !== "completed")
+      return;
+    if (isFailed && status.state !== "error")
+      return;
+    const occurrenceId = typeof part.id === "string" ? part.id : typeof message.info.id === "string" ? `${message.info.id}:${partIndex}` : `${message.info.sessionID ?? "unknown"}:${messageIndex}:${partIndex}`;
+    if (processedInjectedCompletions.has(occurrenceId))
+      return;
+    const updated = updateBackgroundJobFromOutput(part.text);
+    if (!updated)
+      return;
+    rememberProcessedInjectedCompletion(occurrenceId);
+    return updated;
+  }
+  function rememberProcessedInjectedCompletion(signature) {
+    processedInjectedCompletions.add(signature);
+    processedInjectedCompletionOrder.push(signature);
+    while (processedInjectedCompletionOrder.length > MAX_PROCESSED_INJECTED_COMPLETIONS) {
+      const evicted = processedInjectedCompletionOrder.shift();
+      if (!evicted)
+        break;
+      processedInjectedCompletions.delete(evicted);
+    }
+  }
   function isMissingRememberedSessionError(output) {
     const firstLine = output.split(/\r?\n/, 1)[0]?.trim().toLowerCase() ?? "";
     return firstLine.startsWith("[error]") && firstLine.includes("session") && (firstLine.includes("not found") || firstLine.includes("no session"));
@@ -24195,6 +24469,25 @@ function createTaskSessionManagerHook(_ctx, options) {
       return;
     return pendingCallOrder.find((callId) => pendingCalls.get(callId)?.parentSessionId === parentSessionId);
   }
+  function rememberInjectedTerminalJobs(parentSessionID) {
+    const taskIDs = backgroundJobBoard.list(parentSessionID).filter((job) => job.terminalUnreconciled).map((job) => job.taskID);
+    if (taskIDs.length === 0)
+      return;
+    const existing = terminalJobsInjectedByParent.get(parentSessionID) ?? new Set;
+    for (const taskID of taskIDs) {
+      existing.add(taskID);
+    }
+    terminalJobsInjectedByParent.set(parentSessionID, existing);
+  }
+  function reconcileInjectedTerminalJobs(parentSessionID) {
+    const taskIDs = terminalJobsInjectedByParent.get(parentSessionID);
+    if (!taskIDs)
+      return;
+    for (const taskID of taskIDs) {
+      backgroundJobBoard.markReconciled(taskID);
+    }
+    terminalJobsInjectedByParent.delete(parentSessionID);
+  }
   return {
     "tool.execute.before": async (input, output) => {
       if (input.tool.toLowerCase() !== "task")
@@ -24244,11 +24537,31 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
+      if (input.tool.toLowerCase() === "task_status") {
+        if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
+          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) {
+        backgroundJobBoard.registerLaunch({
+          taskID: launch.taskID,
+          parentSessionID: pending.parentSessionId,
+          agent: pending.agentType,
+          description: pending.label,
+          objective: pending.label
+        });
+        sessionManager.drop(pending.parentSessionId, pending.agentType, pending.resumedTaskId ?? launch.taskID);
+        pendingManagedTaskIds.add(launch.taskID);
+        return;
+      }
       const taskId = parseTaskIdFromTaskOutput(output.output);
       if (!taskId) {
         if (pending.resumedTaskId && isMissingRememberedSessionError(output.output)) {
@@ -24271,6 +24584,19 @@ function createTaskSessionManagerHook(_ctx, options) {
       pruneContext();
     },
     "experimental.chat.messages.transform": async (_input, output) => {
+      for (const [messageIndex, message] of output.messages.entries()) {
+        if (message.info.role !== "user")
+          continue;
+        if (message.info.agent && message.info.agent !== "orchestrator") {
+          continue;
+        }
+        if (!message.info.sessionID || !options.shouldManageSession(message.info.sessionID)) {
+          continue;
+        }
+        for (const [partIndex, part] of message.parts.entries()) {
+          updateFromInjectedCompletion(part, message, messageIndex, partIndex);
+        }
+      }
       for (let i = output.messages.length - 1;i >= 0; i -= 1) {
         const message = output.messages[i];
         if (message.info.role !== "user")
@@ -24280,8 +24606,11 @@ function createTaskSessionManagerHook(_ctx, options) {
         if (!message.info.sessionID || !options.shouldManageSession(message.info.sessionID)) {
           return;
         }
-        const reminder = sessionManager.formatForPrompt(message.info.sessionID);
-        if (!reminder)
+        const reminders = [
+          backgroundJobBoard.formatForPrompt(message.info.sessionID),
+          sessionManager.formatForPrompt(message.info.sessionID)
+        ].filter((item) => Boolean(item));
+        if (reminders.length === 0)
           return;
         const textPart = message.parts.find((part) => part.type === "text" && typeof part.text === "string");
         if (!textPart)
@@ -24290,11 +24619,14 @@ function createTaskSessionManagerHook(_ctx, options) {
           return;
         if (textPart.text?.includes(RESUMABLE_SESSIONS_START))
           return;
+        rememberInjectedTerminalJobs(message.info.sessionID);
         textPart.text = [
           textPart.text ?? "",
           "",
           RESUMABLE_SESSIONS_START,
-          reminder,
+          reminders.join(`
+
+`),
           RESUMABLE_SESSIONS_END
         ].join(`
 `);
@@ -24309,13 +24641,30 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
+      if (input.event.type === "session.idle" || input.event.type === "session.status" && input.event.properties?.status?.type === "idle") {
+        const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+        if (sessionId2 && options.shouldManageSession(sessionId2)) {
+          reconcileInjectedTerminalJobs(sessionId2);
+        }
+        return;
+      }
+      if (input.event.type === "session.error") {
+        const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+        if (sessionId2 && options.shouldManageSession(sessionId2)) {
+          terminalJobsInjectedByParent.delete(sessionId2);
+        }
+        return;
+      }
       if (input.event.type !== "session.deleted")
         return;
       const sessionId = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
       if (!sessionId)
         return;
       sessionManager.dropTask(sessionId);
+      backgroundJobBoard.drop(sessionId);
       sessionManager.clearParent(sessionId);
+      backgroundJobBoard.clearParent(sessionId);
+      terminalJobsInjectedByParent.delete(sessionId);
       contextByTask.delete(sessionId);
       pendingManagedTaskIds.delete(sessionId);
       pruneContext();
@@ -24544,6 +24893,7 @@ function createTodoContinuationHook(ctx, config) {
   const cooldownMs = config?.cooldownMs ?? 3000;
   const autoEnable = config?.autoEnable ?? false;
   const autoEnableThreshold = config?.autoEnableThreshold ?? 4;
+  const backgroundJobBoard = config?.backgroundJobBoard;
   const requestSignatureBySession = new Map;
   const state = {
     enabled: false,
@@ -24655,8 +25005,10 @@ function createTodoContinuationHook(ctx, config) {
     }
     if (requestSignatureBySession.get(lastUserMessage.sessionID) === lastUserMessage.signature) {
       const reminder = hygiene.getPendingReminder(lastUserMessage.sessionID);
-      if (reminder) {
-        appendTodoHygieneInstruction(lastUserMessage.message, reminder);
+      const guardrail = backgroundGuardrail(lastUserMessage.sessionID);
+      const combinedReminder = [reminder, guardrail].filter((item) => Boolean(item)).join(" ");
+      if (combinedReminder) {
+        appendTodoHygieneInstruction(lastUserMessage.message, combinedReminder);
       } else {
         stripTodoHygieneInstructionFromMessage(lastUserMessage.message);
       }
@@ -24694,6 +25046,28 @@ function createTodoContinuationHook(ctx, config) {
   function registerOrchestratorSession(sessionID) {
     state.orchestratorSessionIds.add(sessionID);
   }
+  function backgroundGuardrail(sessionID) {
+    if (!backgroundJobBoard)
+      return;
+    const hasRunning = backgroundJobBoard.hasRunning(sessionID);
+    const hasTerminal = backgroundJobBoard.hasTerminalUnreconciled(sessionID);
+    if (hasRunning && hasTerminal) {
+      return "Background jobs are still unresolved: call task_status for running jobs and reconcile terminal Background Job Board results before dependent work or finalizing.";
+    }
+    if (hasTerminal) {
+      return "Background jobs have terminal results: reconcile the Background Job Board results before finalizing.";
+    }
+    if (hasRunning) {
+      return "Background jobs are still running: call task_status before dependent work or finalizing.";
+    }
+    return;
+  }
+  function continuationPrompt(sessionID) {
+    const guardrail = backgroundGuardrail(sessionID);
+    if (!guardrail)
+      return CONTINUATION_PROMPT;
+    return `${CONTINUATION_PROMPT} ${guardrail}`;
+  }
   function handleChatMessage(input) {
     if (!input.agent) {
       return;
@@ -24885,7 +25259,9 @@ function createTodoContinuationHook(ctx, config) {
           await ctx.client.session.prompt({
             path: { id: sessionID },
             body: {
-              parts: [createInternalAgentTextPart(CONTINUATION_PROMPT)]
+              parts: [
+                createInternalAgentTextPart(continuationPrompt(sessionID))
+              ]
             }
           });
           state.consecutiveContinuations++;
@@ -24996,7 +25372,7 @@ function createTodoContinuationHook(ctx, config) {
       });
     }
     if (hasIncompleteTodos) {
-      output.parts.push(createInternalAgentTextPart(`${CONTINUATION_PROMPT} [Auto-continue enabled: up to ${maxContinuations} continuations.]`));
+      output.parts.push(createInternalAgentTextPart(`${continuationPrompt(input.sessionID)} [Auto-continue enabled: up to ${maxContinuations} continuations.]`));
     } else {
       output.parts.push(createInternalAgentTextPart(`[Auto-continue: enabled for up to ${maxContinuations} continuations. No incomplete todos right now.]`));
     }
@@ -33436,6 +33812,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let todoContinuationHook;
   let sessionGoalHook;
   let taskSessionManagerHook;
+  let backgroundJobBoard;
   let interviewManager;
   let presetManager;
   let divoomManager;
@@ -33521,11 +33898,13 @@ var OhMyOpenCodeLite = async (ctx) => {
     applyPatchHook = createApplyPatchHook(ctx);
     jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
     foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
+    backgroundJobBoard = new BackgroundJobBoard;
     todoContinuationHook = createTodoContinuationHook(ctx, {
       maxContinuations: config.todoContinuation?.maxContinuations ?? 5,
       cooldownMs: config.todoContinuation?.cooldownMs ?? 3000,
       autoEnable: config.todoContinuation?.autoEnable ?? false,
-      autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4
+      autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4,
+      backgroundJobBoard
     });
     sessionGoalHook = createSessionGoalHook(ctx, config, {
       getAgentName: (sessionID) => sessionAgentMap.get(sessionID)
@@ -33534,6 +33913,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       maxSessionsPerAgent: config.sessionManager?.maxSessionsPerAgent ?? 2,
       readContextMinLines: config.sessionManager?.readContextMinLines ?? 10,
       readContextMaxFiles: config.sessionManager?.readContextMaxFiles ?? 8,
+      backgroundJobBoard,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
     });
     interviewManager = createInterviewManager(ctx, config);