oh-my-opencode-slim 1.0.7 → 1.1.0

package/dist/index.js

@@ -18220,6 +18220,12 @@ var CUSTOM_SKILLS = [
     description: "Repository understanding and hierarchical codemap generation",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/codemap"
+  },
+  {
+    name: "clonedeps",
+    description: "Clone important dependency source for local inspection",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/clonedeps"
   }
 ];
 
@@ -18393,6 +18399,56 @@ var CouncilConfigSchema = z.object({
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+// src/utils/compat.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { writeFile as fsWriteFile } from "node:fs/promises";
+var isBun = typeof globalThis.Bun !== "undefined";
+function collectStream(stream) {
+  if (!stream)
+    return () => Promise.resolve("");
+  const chunks = [];
+  stream.on("data", (chunk) => chunks.push(chunk));
+  return () => new Promise((resolve, reject) => {
+    if (!stream.readable) {
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+      return;
+    }
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stream.on("error", reject);
+  });
+}
+function crossSpawn(command, options) {
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    stdio: [
+      options?.stdin ?? "ignore",
+      options?.stdout ?? "pipe",
+      options?.stderr ?? "pipe"
+    ],
+    cwd: options?.cwd,
+    env: options?.env
+  });
+  const stdoutCollector = collectStream(proc.stdout);
+  const stderrCollector = collectStream(proc.stderr);
+  const exited = new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  return {
+    proc,
+    stdout: stdoutCollector,
+    stderr: stderrCollector,
+    exited,
+    kill: (signal) => proc.kill(signal),
+    get exitCode() {
+      return proc.exitCode;
+    }
+  };
+}
+async function crossWrite(path, data) {
+  await fsWriteFile(path, Buffer.from(data));
+}
+
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
   orchestrator: ["*", "!context7"],
@@ -18842,13 +18898,16 @@ function parseModelReference(model) {
     modelID: model.slice(slashIndex + 1)
   };
 }
-async function promptWithTimeout(client, args, timeoutMs) {
+async function promptWithTimeout(client, args, timeoutMs, signal) {
+  if (signal?.aborted)
+    throw new Error("Prompt cancelled");
   if (timeoutMs <= 0) {
     await client.session.prompt(args);
     return;
   }
   const sessionId = args.path.id;
   let timer;
+  let onAbort;
   try {
     const promptPromise = client.session.prompt(args);
     promptPromise.catch(() => {});
@@ -18858,6 +18917,16 @@ async function promptWithTimeout(client, args, timeoutMs) {
         timer = setTimeout(() => {
           reject(new OperationTimeoutError(`Prompt timed out after ${timeoutMs}ms`));
         }, timeoutMs);
+      }),
+      new Promise((_, reject) => {
+        if (!signal)
+          return;
+        if (signal.aborted) {
+          reject(new Error("Prompt cancelled"));
+          return;
+        }
+        onAbort = () => reject(new Error("Prompt cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
       })
     ]);
   } catch (error) {
@@ -18869,12 +18938,15 @@ async function promptWithTimeout(client, args, timeoutMs) {
     throw error;
   } finally {
     clearTimeout(timer);
+    if (onAbort)
+      signal?.removeEventListener("abort", onAbort);
   }
 }
 async function extractSessionResult(client, sessionId, options) {
   const includeReasoning = options?.includeReasoning ?? true;
   const messagesResult = await client.session.messages({
-    path: { id: sessionId }
+    path: { id: sessionId },
+    ...options?.directory ? { query: { directory: options.directory } } : {}
   });
   const messages = messagesResult.data ?? [];
   const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
@@ -19030,6 +19102,25 @@ ${enabledParallelExamples}
 
 Balance: respect dependencies, avoid parallelizing what must be sequential.
 
+### Context Isolation
+If no specialist delegation is needed, consider \`subtask\` before doing
+context-heavy work directly.
+
+Ask whether the parent context needs the details or only the result. Use
+\`subtask\` when the work is bounded, context-heavy, and the parent only needs a
+compact outcome.
+
+Use \`subtask\` for focused investigation, bounded analysis, cleanup, or
+verification across files/logs/messages.
+
+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.
+
+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.
@@ -21966,6 +22057,15 @@ var APPLY_PATCH_RESCUE_OPTIONS = {
   prefixSuffix: true,
   lcsRescue: true
 };
+function replacePatchArgs(output, args, patchText) {
+  const nextArgs = { ...args, patchText };
+  try {
+    output.args = nextArgs;
+  } catch {
+    return false;
+  }
+  return output.args?.patchText === patchText;
+}
 function createApplyPatchHook(ctx) {
   function logHookStatus(state, data) {
     log(`apply-patch hook ${state}`, data);
@@ -21985,8 +22085,16 @@ function createApplyPatchHook(ctx) {
       try {
         const result = await rewritePatch(root, patchText, APPLY_PATCH_RESCUE_OPTIONS, worktree);
         if (result.changed) {
-          args.patchText = result.patchText;
-          logHookStatus("rewrite");
+          if (replacePatchArgs(output, args, result.patchText)) {
+            logHookStatus("rewrite");
+          } else {
+            logHookStatus("skipped", {
+              reason: "readonly output args",
+              failOpen: true,
+              rescueOptions: APPLY_PATCH_RESCUE_OPTIONS,
+              rewriteStage: "before-native"
+            });
+          }
           return;
         }
         logHookStatus("unchanged");
@@ -22018,56 +22126,6 @@ function createApplyPatchHook(ctx) {
     }
   };
 }
-// src/utils/compat.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import { writeFile as fsWriteFile } from "node:fs/promises";
-var isBun = typeof globalThis.Bun !== "undefined";
-function collectStream(stream) {
-  if (!stream)
-    return () => Promise.resolve("");
-  const chunks = [];
-  stream.on("data", (chunk) => chunks.push(chunk));
-  return () => new Promise((resolve, reject) => {
-    if (!stream.readable) {
-      resolve(Buffer.concat(chunks).toString("utf-8"));
-      return;
-    }
-    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    stream.on("error", reject);
-  });
-}
-function crossSpawn(command, options) {
-  const [cmd, ...args] = command;
-  const proc = nodeSpawn(cmd, args, {
-    stdio: [
-      options?.stdin ?? "ignore",
-      options?.stdout ?? "pipe",
-      options?.stderr ?? "pipe"
-    ],
-    cwd: options?.cwd,
-    env: options?.env
-  });
-  const stdoutCollector = collectStream(proc.stdout);
-  const stderrCollector = collectStream(proc.stderr);
-  const exited = new Promise((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve(code ?? 1));
-  });
-  return {
-    proc,
-    stdout: stdoutCollector,
-    stderr: stderrCollector,
-    exited,
-    kill: (signal) => proc.kill(signal),
-    get exitCode() {
-      return proc.exitCode;
-    }
-  };
-}
-async function crossWrite(path6, data) {
-  await fsWriteFile(path6, Buffer.from(data));
-}
-
 // src/hooks/auto-update-checker/cache.ts
 import * as fs5 from "node:fs";
 import * as path8 from "node:path";
@@ -28644,7 +28702,11 @@ class TmuxMultiplexer {
     this.storedLayout = layout;
     this.storedMainPaneSize = mainPaneSize;
     try {
-      const layoutResult = await this.runTmux(tmux, ["select-layout", ...this.targetArgs(), layout]);
+      const layoutResult = await this.runTmux(tmux, [
+        "select-layout",
+        ...this.targetArgs(),
+        layout
+      ]);
       if (layoutResult !== 0)
         return;
       if (layout === "main-horizontal" || layout === "main-vertical") {
@@ -28657,7 +28719,11 @@ class TmuxMultiplexer {
         ]);
         if (sizeResult !== 0)
           return;
-        const reapplyResult = await this.runTmux(tmux, ["select-layout", ...this.targetArgs(), layout]);
+        const reapplyResult = await this.runTmux(tmux, [
+          "select-layout",
+          ...this.targetArgs(),
+          layout
+        ]);
         if (reapplyResult !== 0)
           return;
       }
@@ -32572,6 +32638,460 @@ function createWebfetchTool(pluginCtx, options = {}) {
     }
   });
 }
+// src/tools/subtask/command.ts
+var COMMAND_NAME4 = "subtask";
+var SUBTASK_COMMAND_TEMPLATE = `Start a focused subtask worker.
+
+The user's request below is the full scope for the worker. Do not broaden it.
+Create a self-contained worker prompt that includes:
+- the exact objective
+- relevant context from this conversation
+- specific files/paths that matter
+- expected deliverables
+- validation the worker should run, if applicable
+
+USER REQUEST:
+$ARGUMENTS
+
+Then call the subtask tool:
+\`subtask(prompt="...", files=["src/foo.ts", "docs/bar.md"])\`
+
+Only include files that are clearly relevant. If no files are needed, omit files.`;
+function createSubtaskCommandManager(_ctx, state) {
+  function registerCommand(opencodeConfig) {
+    const configCommand = opencodeConfig.command;
+    if (!configCommand?.[COMMAND_NAME4]) {
+      if (!opencodeConfig.command) {
+        opencodeConfig.command = {};
+      }
+      opencodeConfig.command[COMMAND_NAME4] = {
+        description: "Create a focused subtask prompt for a new session",
+        template: SUBTASK_COMMAND_TEMPLATE
+      };
+    }
+  }
+  return {
+    registerCommand,
+    handleEvent(input) {
+      if (input.event.type === "session.created") {
+        const info = input.event.properties?.info;
+        if (!info?.id || !info.parentID)
+          return;
+        const source = state.sourceFor(info.parentID);
+        if (source)
+          state.markSession(info.id, source);
+        return;
+      }
+      if (input.event.type !== "session.deleted")
+        return;
+      const sessionID = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+      if (sessionID)
+        state.unmarkSession(sessionID);
+    }
+  };
+}
+// src/tools/subtask/files.ts
+import * as fs11 from "node:fs/promises";
+import * as path20 from "node:path";
+
+// src/tools/subtask/vendor.ts
+import * as fs10 from "node:fs/promises";
+import * as path19 from "node:path";
+var DEFAULT_READ_LIMIT = 2000;
+var MAX_LINE_LENGTH = 2000;
+var MAX_BYTES = 50 * 1024;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var SAMPLE_BYTES = 4096;
+var BINARY_EXTENSIONS = new Set([
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".class",
+  ".jar",
+  ".war",
+  ".7z",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".bin",
+  ".dat",
+  ".obj",
+  ".o",
+  ".a",
+  ".lib",
+  ".wasm",
+  ".pyc",
+  ".pyo"
+]);
+async function isBinaryFile(filepath) {
+  const ext = path19.extname(filepath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) {
+    return true;
+  }
+  try {
+    const file = await fs10.open(filepath, "r");
+    try {
+      const buffer = Buffer.alloc(SAMPLE_BYTES);
+      const result = await file.read(buffer, 0, SAMPLE_BYTES, 0);
+      if (result.bytesRead === 0)
+        return false;
+      const bytes = buffer.subarray(0, result.bytesRead);
+      let nonPrintableCount = 0;
+      for (let i = 0;i < bytes.length; i++) {
+        const byte = bytes[i];
+        if (byte === undefined)
+          continue;
+        if (byte === 0)
+          return true;
+        if (byte < 9 || byte > 13 && byte < 32) {
+          nonPrintableCount++;
+        }
+      }
+      return nonPrintableCount / bytes.length > 0.3;
+    } finally {
+      await file.close();
+    }
+  } catch {
+    return false;
+  }
+}
+function formatFileContent(_filepath, content) {
+  const cappedContent = Buffer.byteLength(content, "utf8") > MAX_BYTES;
+  const contentToFormat = cappedContent ? content.slice(0, MAX_BYTES) : content;
+  const lines = contentToFormat.split(`
+`);
+  const limit = DEFAULT_READ_LIMIT;
+  const offset = 0;
+  const raw = lines.slice(offset, offset + limit).map((line) => {
+    return line.length > MAX_LINE_LENGTH ? `${line.substring(0, MAX_LINE_LENGTH)}${MAX_LINE_SUFFIX}` : line;
+  });
+  const formatted = raw.map((line, index) => {
+    return `${index + offset + 1}: ${line}`;
+  });
+  let output = [
+    `<path>${_filepath}</path>`,
+    "<type>file</type>",
+    `<content>
+`
+  ].join(`
+`);
+  output += formatted.join(`
+`);
+  const totalLines = lines.length;
+  const lastReadLine = offset + formatted.length;
+  const hasMoreLines = totalLines > lastReadLine;
+  if (cappedContent) {
+    output += `
+
+(Output capped at ${MAX_BYTES_LABEL}. Showing lines 1-${lastReadLine}. Use offset=${lastReadLine + 1} to continue.)`;
+  } else if (hasMoreLines) {
+    output += `
+
+(Showing lines 1-${lastReadLine} of ${totalLines}. Use offset=${lastReadLine + 1} to continue.)`;
+  } else {
+    output += `
+
+(End of file - total ${totalLines} lines)`;
+  }
+  output += `
+</content>`;
+  return output;
+}
+
+// src/tools/subtask/files.ts
+var FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g;
+var TRAILING_PATH_PUNCTUATION = /[!?:;]+$/;
+function cleanFileReference(ref) {
+  return ref.replace(/^@/, "").replace(TRAILING_PATH_PUNCTUATION, "");
+}
+function parseFileReferences(text) {
+  const fileRefs = new Set;
+  for (const match of text.matchAll(FILE_REGEX)) {
+    if (match[1]) {
+      fileRefs.add(cleanFileReference(match[1]));
+    }
+  }
+  return fileRefs;
+}
+async function buildSyntheticFileParts(directory, refs) {
+  const parts = [];
+  const realDirectory = await fs11.realpath(directory);
+  for (const ref of refs) {
+    const filepath = path20.resolve(directory, ref);
+    const relative3 = path20.relative(directory, filepath);
+    if (relative3.startsWith("..") || path20.isAbsolute(relative3))
+      continue;
+    try {
+      const realFilepath = await fs11.realpath(filepath);
+      const realRelative = path20.relative(realDirectory, realFilepath);
+      if (realRelative.startsWith("..") || path20.isAbsolute(realRelative)) {
+        continue;
+      }
+      const stats = await fs11.stat(realFilepath);
+      if (!stats.isFile())
+        continue;
+      if (await isBinaryFile(realFilepath))
+        continue;
+      const content = await fs11.readFile(realFilepath, "utf-8");
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: realFilepath })}`
+      });
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: formatFileContent(realFilepath, content)
+      });
+    } catch {}
+  }
+  return parts;
+}
+// src/tools/subtask/state.ts
+function createSubtaskState() {
+  const sourceBySession = new Map;
+  return {
+    markSession(sessionID, sourceSessionID) {
+      sourceBySession.set(sessionID, sourceSessionID);
+    },
+    unmarkSession(sessionID) {
+      sourceBySession.delete(sessionID);
+    },
+    isSubtaskSession(sessionID) {
+      return sourceBySession.has(sessionID);
+    },
+    sourceFor(sessionID) {
+      return sourceBySession.get(sessionID);
+    }
+  };
+}
+// src/tools/subtask/tools.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+var SUBTASK_TIMEOUT_MS = 5 * 60 * 1000;
+var SUBTASK_SUMMARY_TAG_REGEX = /<\/?subtask_summary>/g;
+function normalizeSubtaskSummary(text) {
+  return text.replace(SUBTASK_SUMMARY_TAG_REGEX, "").trim();
+}
+function getAbortSignal(context) {
+  if (!context || typeof context !== "object" || !("abort" in context)) {
+    return;
+  }
+  const signal = context.abort;
+  return signal && typeof signal === "object" && "addEventListener" in signal && "removeEventListener" in signal && "aborted" in signal ? signal : undefined;
+}
+function createSubtaskTool(ctx, state, depthTracker) {
+  const client = ctx.client;
+  return tool5({
+    description: "Run a child worker session and return its completion summary to the caller",
+    args: {
+      prompt: tool5.schema.string().describe("The generated subtask prompt"),
+      files: tool5.schema.array(tool5.schema.string()).optional().describe("Array of file paths to load into the new session's context")
+    },
+    async execute(args, context) {
+      const directory = context && typeof context === "object" && "directory" in context && typeof context.directory === "string" ? context.directory : ctx.directory;
+      const sessionID = context && typeof context === "object" && "sessionID" in context ? context.sessionID : "unknown";
+      const abortSignal = getAbortSignal(context);
+      if (state.isSubtaskSession(sessionID)) {
+        return "Nested subtask is disabled: this session is already a subtask worker. Finish this worker and return its summary to the parent session instead.";
+      }
+      if (sessionID !== "unknown" && depthTracker && depthTracker.getDepth(sessionID) + 1 > depthTracker.maxDepth) {
+        return `Subtask worker blocked: max subagent depth ${depthTracker.maxDepth} would be exceeded.`;
+      }
+      const sessionReference = `You are a subtask worker spawned by parent session ${sessionID}.
+
+Your job is bounded: complete only the task below. Do not expand scope.
+If needed context is missing, use read_session to inspect the parent session.
+Do not spawn another subtask.`;
+      const files = new Set([
+        ...parseFileReferences(args.prompt),
+        ...(args.files ?? []).map(cleanFileReference)
+      ]);
+      const fileRefs = files.size > 0 ? [...files].map((f) => `@${f}`).join(" ") : "";
+      const fullPrompt = fileRefs ? `${sessionReference}
+
+TASK:
+${args.prompt}
+
+FILES PROVIDED:
+${fileRefs}` : `${sessionReference}
+
+TASK:
+${args.prompt}`;
+      let childSessionID;
+      try {
+        const session2 = await client.session.create({
+          responseStyle: "data",
+          throwOnError: true,
+          query: { directory },
+          body: {
+            parentID: sessionID === "unknown" ? undefined : sessionID,
+            title: `Subtask worker from ${sessionID}`
+          }
+        });
+        childSessionID = session2?.data?.id ?? session2?.id;
+        if (!childSessionID) {
+          throw new Error("Subtask worker session did not return an id");
+        }
+        if (sessionID !== "unknown" && depthTracker) {
+          const registered = depthTracker.registerChild(sessionID, childSessionID);
+          if (!registered) {
+            throw new Error("Subtask worker blocked: max subagent depth exceeded");
+          }
+        }
+        state.markSession(childSessionID, sessionID);
+        await promptWithTimeout(client, {
+          responseStyle: "data",
+          throwOnError: true,
+          query: { directory },
+          path: { id: childSessionID },
+          body: {
+            agent: "orchestrator",
+            parts: [
+              {
+                type: "text",
+                text: `${fullPrompt}
+
+Instructions:
+1. Understand the task and relevant file context.
+2. Make only necessary changes.
+3. Run the most relevant validation checks when practical.
+4. Stop when the requested task is done.
+
+Return your final response in this format:
+
+<subtask_summary>
+Status: completed | blocked | partial
+
+What changed:
+- ...
+
+Files touched:
+- ...
+
+Validation:
+- ...
+
+Risks / follow-up:
+- ...
+</subtask_summary>`
+              },
+              ...await buildSyntheticFileParts(directory, files)
+            ]
+          }
+        }, SUBTASK_TIMEOUT_MS, abortSignal);
+        const extraction = await extractSessionResult(client, childSessionID, {
+          directory,
+          includeReasoning: false
+        });
+        if (extraction.empty) {
+          throw new Error("Subtask worker returned no summary");
+        }
+        const summary = normalizeSubtaskSummary(extraction.text);
+        return [
+          `task_id: ${childSessionID}`,
+          "",
+          "<subtask_summary>",
+          summary,
+          "</subtask_summary>"
+        ].join(`
+`);
+      } finally {
+        if (childSessionID) {
+          try {
+            await client.session.abort({
+              path: { id: childSessionID },
+              query: { directory }
+            });
+            state.unmarkSession(childSessionID);
+          } catch {}
+        }
+      }
+    }
+  });
+}
+function formatTranscript(messages, limit) {
+  const lines = [];
+  for (const msg of messages) {
+    const role = msg.info?.role;
+    const parts = msg.parts;
+    if (role === "user") {
+      lines.push("## User");
+      for (const part of parts) {
+        if (part.type === "text" && !part.ignored && typeof part.text === "string") {
+          lines.push(part.text);
+        }
+        if (part.type === "file") {
+          lines.push(`[Attached: ${part.filename || "file"}]`);
+        }
+      }
+      lines.push("");
+    }
+    if (role === "assistant") {
+      lines.push("## Assistant");
+      for (const part of parts) {
+        if (part.type === "text" && typeof part.text === "string") {
+          lines.push(part.text);
+        }
+        if (part.type === "tool" && part.state?.status === "completed" && part.tool) {
+          lines.push(`[Tool: ${part.tool}] ${part.state.title ?? ""}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  const output = lines.join(`
+`).trim();
+  if (messages.length >= (limit ?? 100)) {
+    return output + `
+
+(Showing ${messages.length} most recent messages. Use a higher 'limit' to see more.)`;
+  }
+  return `${output}
+
+(End of session - ${messages.length} messages)`;
+}
+function createReadSessionTool(client, state) {
+  return tool5({
+    description: "Read the conversation transcript from a previous session. Use this when you need specific information from the source session that wasn't included in the subtask summary.",
+    args: {
+      sessionID: tool5.schema.string().describe("The full session ID (e.g., sess_01jxyz...)"),
+      limit: tool5.schema.number().optional().describe("Maximum number of messages to read (defaults to 100, max 500)")
+    },
+    async execute(args, context) {
+      const limit = Math.min(args.limit ?? 100, 500);
+      const directory = context && typeof context === "object" && "directory" in context && typeof context.directory === "string" ? context.directory : undefined;
+      const callerSessionID = context && typeof context === "object" && "sessionID" in context ? context.sessionID : undefined;
+      if (!callerSessionID || !state.isSubtaskSession(callerSessionID)) {
+        return "read_session is only available from subtask worker sessions.";
+      }
+      if (state.sourceFor(callerSessionID) !== args.sessionID) {
+        return "read_session can only read the source session for this subtask worker.";
+      }
+      try {
+        const response = await client.session.messages({
+          path: { id: args.sessionID },
+          query: { limit, ...directory ? { directory } : {} }
+        });
+        if (!response.data || response.data.length === 0) {
+          return "Session has no messages or does not exist.";
+        }
+        return formatTranscript(response.data, limit);
+      } catch (error) {
+        return `Could not read session ${args.sessionID}: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
 // src/utils/subagent-depth.ts
 class SubagentDepthTracker {
   depthBySession = new Map;
@@ -32691,6 +33211,8 @@ var OhMyOpenCodeLite = async (ctx) => {
   let councilTools;
   let webfetch;
   let rewriteDisplayNameMentions;
+  let subtaskCommandManager;
+  let subtaskState;
   let toolCount = 0;
   try {
     config = loadPluginConfig(ctx.directory);
@@ -32783,7 +33305,9 @@ var OhMyOpenCodeLite = async (ctx) => {
     interviewManager = createInterviewManager(ctx, config);
     presetManager = createPresetManager(ctx, config);
     divoomManager = createDivoomManager(config.divoom);
-    toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2;
+    subtaskState = createSubtaskState();
+    subtaskCommandManager = createSubtaskCommandManager(ctx, subtaskState);
+    toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2 + 2;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
     await appLog(ctx, "error", `INIT FAILED: ${String(err)}. Report at github.com/alvinunreal/oh-my-opencode-slim/issues/310`);
@@ -32828,7 +33352,9 @@ var OhMyOpenCodeLite = async (ctx) => {
       webfetch,
       ...todoContinuationHook.tool,
       ast_grep_search,
-      ast_grep_replace
+      ast_grep_replace,
+      subtask: createSubtaskTool(ctx, subtaskState, depthTracker),
+      read_session: createReadSessionTool(ctx.client, subtaskState)
     },
     mcp: mcps,
     config: async (opencodeConfig) => {
@@ -33025,6 +33551,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       }
       interviewManager.registerCommand(opencodeConfig);
       presetManager.registerCommand(opencodeConfig);
+      subtaskCommandManager.registerCommand(opencodeConfig);
     },
     event: async (input) => {
       const event = input.event;
@@ -33052,6 +33579,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionDeleted(event);
       await interviewManager.handleEvent(input);
       await taskSessionManagerHook.event(input);
+      subtaskCommandManager.handleEvent(input);
       if (event.type === "permission.asked" || event.type === "question.asked") {
         const props = event.properties;
         divoomManager.onUserInputRequired({