oh-my-opencode-slim 1.0.1 → 1.0.3

package/dist/index.js

@@ -6246,33 +6246,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path13) {
-        if (!path13)
-          return path13;
+      function remove_dot_segments(path14) {
+        if (!path14)
+          return path14;
         var output = "";
-        while (path13.length > 0) {
-          if (path13 === "." || path13 === "..") {
-            path13 = "";
+        while (path14.length > 0) {
+          if (path14 === "." || path14 === "..") {
+            path14 = "";
             break;
           }
-          var twochars = path13.substring(0, 2);
-          var threechars = path13.substring(0, 3);
-          var fourchars = path13.substring(0, 4);
+          var twochars = path14.substring(0, 2);
+          var threechars = path14.substring(0, 3);
+          var fourchars = path14.substring(0, 4);
           if (threechars === "../") {
-            path13 = path13.substring(3);
+            path14 = path14.substring(3);
           } else if (twochars === "./") {
-            path13 = path13.substring(2);
+            path14 = path14.substring(2);
           } else if (threechars === "/./") {
-            path13 = "/" + path13.substring(3);
-          } else if (twochars === "/." && path13.length === 2) {
-            path13 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path13.length === 3) {
-            path13 = "/" + path13.substring(4);
+            path14 = "/" + path14.substring(3);
+          } else if (twochars === "/." && path14.length === 2) {
+            path14 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path14.length === 3) {
+            path14 = "/" + path14.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path13.match(/(\/?([^\/]*))/)[0];
+            var segment = path14.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path13 = path13.substring(segment.length);
+            path14 = path14.substring(segment.length);
           }
         }
         return output;
@@ -18302,7 +18302,7 @@ var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
 var PROTECTED_AGENTS = new Set(["orchestrator", "councillor"]);
 var DEFAULT_MODELS = {
   orchestrator: undefined,
-  oracle: "openai/gpt-5.4",
+  oracle: "openai/gpt-5.5",
   librarian: "openai/gpt-5.4-mini",
   explorer: "openai/gpt-5.4-mini",
   designer: "openai/gpt-5.4-mini",
@@ -18316,7 +18316,7 @@ 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 agents delegation rules → don't prefer solo → execute → verify.
+Understand → choose the best parallelized path based on your capabilities and agents delegation rules → execute → verify.
 If delegating, launch the specialist in the same turn you mention it !END!`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
@@ -18525,6 +18525,11 @@ var InterviewConfigSchema = z2.object({
   port: z2.number().int().min(0).max(65535).default(0),
   dashboard: z2.boolean().default(false)
 });
+var SessionManagerConfigSchema = z2.object({
+  maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
+  readContextMinLines: z2.number().int().min(0).max(1000).default(10),
+  readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
+});
 var TodoContinuationConfigSchema = z2.object({
   maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
   cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
@@ -18566,6 +18571,7 @@ var PluginConfigSchema = z2.object({
   scoringEngineVersion: z2.enum(["v1", "v2-shadow", "v2"]).optional(),
   balanceProviderUsage: z2.boolean().optional(),
   showStartupToast: z2.boolean().optional().describe("Show the startup activation toast when OpenCode starts. Defaults to true."),
+  autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
   manualPlan: ManualPlanSchema.optional(),
   presets: z2.record(z2.string(), PresetSchema).optional(),
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
@@ -18575,6 +18581,7 @@ var PluginConfigSchema = z2.object({
   tmux: TmuxConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   interview: InterviewConfigSchema.optional(),
+  sessionManager: SessionManagerConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
@@ -18660,6 +18667,7 @@ function loadPluginConfig(directory) {
       tmux: deepMerge(config.tmux, projectConfig.tmux),
       multiplexer: deepMerge(config.multiplexer, projectConfig.multiplexer),
       interview: deepMerge(config.interview, projectConfig.interview),
+      sessionManager: deepMerge(config.sessionManager, projectConfig.sessionManager),
       fallback: deepMerge(config.fallback, projectConfig.fallback),
       council: deepMerge(config.council, projectConfig.council)
     };
@@ -18931,6 +18939,12 @@ ${enabledParallelExamples}
 
 Balance: respect dependencies, avoid parallelizing what must be sequential.
 
+### 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
@@ -18938,6 +18952,12 @@ Balance: respect dependencies, avoid parallelizing what must be sequential.
 4. Integrate results
 5. Adjust if needed
 
+### Session Reuse
+- Reuse an available specialist session only for clear follow-up work on the same thread.
+- Prefer a fresh session for unrelated work, even with the same specialist.
+- If multiple remembered sessions fit, prefer the most recently used matching session.
+- If reuse is unclear, start a fresh session.
+
 ### Auto-Continue
 When working through multi-step tasks, consider enabling auto-continue to avoid stopping between batches:
 - **Enable when:** User requests autonomous/batch work, or you create 4+ todos in a session
@@ -19751,12 +19771,14 @@ function getDisabledAgents(config) {
 
 // src/utils/logger.ts
 import * as fs2 from "node:fs";
+import { appendFile } from "node:fs/promises";
 import * as os from "node:os";
 import * as path2 from "node:path";
 var LOG_PREFIX = "oh-my-opencode-slim.";
 var LOG_SUFFIX = ".log";
 var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 var logFile = null;
+var writeChain = Promise.resolve();
 function getLogDir() {
   return process.env.OPENCODE_LOG_DIR ?? path2.join(os.homedir(), ".local/share/opencode");
 }
@@ -19799,10 +19821,14 @@ function initLogger(sessionId) {
     fs2.mkdirSync(dir, { recursive: true });
   } catch {}
   logFile = path2.join(dir, `${LOG_PREFIX}${sessionId}${LOG_SUFFIX}`);
+  try {
+    fs2.closeSync(fs2.openSync(logFile, "a"));
+  } catch {}
   cleanupOldLogs(dir);
 }
 function log(message, data) {
-  if (!logFile)
+  const target = logFile;
+  if (!target)
     return;
   try {
     const timestamp = new Date().toISOString();
@@ -19816,7 +19842,7 @@ function log(message, data) {
     }
     const logEntry = `[${timestamp}] ${message} ${dataStr}
 `;
-    fs2.appendFileSync(logFile, logEntry);
+    writeChain = writeChain.then(() => appendFile(target, logEntry)).catch(() => {});
   } catch {}
 }
 
@@ -20002,7 +20028,7 @@ class CouncilManager {
       }
     } else {
       const promises = entries.map(([name, config], index) => (async () => {
-        if (index > 0) {
+        if (this.tmuxEnabled && index > 0) {
           await new Promise((r) => setTimeout(r, index * COUNCILLOR_STAGGER_MS));
         }
         return this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries);
@@ -22018,11 +22044,8 @@ function resolveRuntimeAgentName(config, agentName) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function rewriteDisplayNameMentions(config, text) {
-  if (!text.includes("@")) {
-    return text;
-  }
-  let rewritten = text;
+function createDisplayNameMentionRewriter(config) {
+  const replacements = [];
   for (const internalName of getRuntimeAgentNames(config)) {
     const displayName = getAgentOverride(config, internalName)?.displayName;
     if (!displayName) {
@@ -22032,9 +22055,24 @@ function rewriteDisplayNameMentions(config, text) {
     if (!normalizedDisplayName || normalizedDisplayName === internalName) {
       continue;
     }
-    rewritten = rewritten.replace(new RegExp(`(^|[^\\w.])@${escapeRegExp2(normalizedDisplayName)}\\b`, "g"), `$1@${internalName}`);
+    replacements.push({
+      regex: new RegExp(`(^|[^\\w.])@${escapeRegExp2(normalizedDisplayName)}\\b`, "g"),
+      internalName
+    });
+  }
+  if (replacements.length === 0) {
+    return (text) => text;
   }
-  return rewritten;
+  return (text) => {
+    if (!text.includes("@")) {
+      return text;
+    }
+    let rewritten = text;
+    for (const replacement of replacements) {
+      rewritten = rewritten.replace(replacement.regex, `$1@${replacement.internalName}`);
+    }
+    return rewritten;
+  };
 }
 // src/utils/internal-initiator.ts
 var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
@@ -22057,6 +22095,249 @@ function hasInternalInitiatorMarker(part) {
   }
   return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
 }
+// src/utils/session-manager.ts
+var MIN_CONTEXT_FILE_LINES = 10;
+var MAX_CONTEXT_FILES_PER_SESSION = 8;
+function aliasPrefix(agentType) {
+  switch (agentType) {
+    case "explorer":
+      return "exp";
+    case "librarian":
+      return "lib";
+    case "oracle":
+      return "ora";
+    case "designer":
+      return "des";
+    case "fixer":
+      return "fix";
+    case "observer":
+      return "obs";
+    case "council":
+      return "cnc";
+    case "councillor":
+      return "clr";
+    case "orchestrator":
+      return "orc";
+  }
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function deriveTaskSessionLabel(input) {
+  const preferred = normalizeWhitespace(input.description ?? "");
+  if (preferred) {
+    return preferred.slice(0, 48);
+  }
+  const firstPromptLine = (input.prompt ?? "").split(/\r?\n/).map((line) => normalizeWhitespace(line)).find(Boolean);
+  if (firstPromptLine) {
+    return firstPromptLine.slice(0, 48);
+  }
+  return `recent ${input.agentType} task`;
+}
+
+class SessionManager {
+  maxSessionsPerAgent;
+  readContextMinLines;
+  readContextMaxFiles;
+  sessionsByParent = new Map;
+  nextAliasIndexByParent = new Map;
+  orderCounter = 0;
+  constructor(maxSessionsPerAgent, options = {}) {
+    this.maxSessionsPerAgent = maxSessionsPerAgent;
+    this.readContextMinLines = options.readContextMinLines ?? MIN_CONTEXT_FILE_LINES;
+    this.readContextMaxFiles = options.readContextMaxFiles ?? MAX_CONTEXT_FILES_PER_SESSION;
+  }
+  remember(input) {
+    const now = this.nextOrder();
+    const group = this.getAgentGroup(input.parentSessionId, input.agentType, true);
+    if (!group) {
+      throw new Error("Failed to initialize session group");
+    }
+    const existing = group.find((entry) => entry.taskId === input.taskId);
+    if (existing) {
+      existing.label = input.label;
+      existing.lastUsedAt = this.nextOrder();
+      return existing;
+    }
+    const remembered = {
+      alias: this.nextAlias(input.parentSessionId, input.agentType),
+      taskId: input.taskId,
+      agentType: input.agentType,
+      label: input.label,
+      contextFiles: [],
+      createdAt: now,
+      lastUsedAt: now
+    };
+    group.push(remembered);
+    this.trimGroup(group);
+    return remembered;
+  }
+  markUsed(parentSessionId, agentType, key) {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    const match = group?.find((entry) => entry.alias === key || entry.taskId === key);
+    if (match) {
+      match.lastUsedAt = this.nextOrder();
+    }
+  }
+  resolve(parentSessionId, agentType, key) {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    return group?.find((entry) => entry.alias === key || entry.taskId === key);
+  }
+  drop(parentSessionId, agentType, key) {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    if (!group)
+      return;
+    const next = group.filter((entry) => entry.alias !== key && entry.taskId !== key);
+    this.setAgentGroup(parentSessionId, agentType, next);
+  }
+  dropTask(taskId) {
+    for (const [parentSessionId, groups] of this.sessionsByParent.entries()) {
+      for (const [agentType, group] of groups.entries()) {
+        const next = group.filter((entry) => entry.taskId !== taskId);
+        this.setAgentGroup(parentSessionId, agentType, next);
+      }
+    }
+  }
+  taskIds() {
+    const ids = new Set;
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        for (const entry of group) {
+          ids.add(entry.taskId);
+        }
+      }
+    }
+    return ids;
+  }
+  addContext(taskId, files) {
+    if (files.length === 0)
+      return;
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        const match = group.find((entry) => entry.taskId === taskId);
+        if (!match)
+          continue;
+        const existing = new Map(match.contextFiles.map((file) => [file.path, file]));
+        for (const file of files) {
+          const previous = existing.get(file.path);
+          if (previous) {
+            previous.lineCount = Math.max(previous.lineCount, file.lineCount);
+            previous.lastReadAt = Math.max(previous.lastReadAt, file.lastReadAt);
+            continue;
+          }
+          match.contextFiles.push({ ...file });
+        }
+        this.trimContextFiles(match);
+      }
+    }
+  }
+  clearParent(parentSessionId) {
+    this.sessionsByParent.delete(parentSessionId);
+    this.nextAliasIndexByParent.delete(parentSessionId);
+  }
+  formatForPrompt(parentSessionId) {
+    const groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups || groups.size === 0)
+      return;
+    const lines = [...groups.entries()].map(([agentType, entries]) => [
+      agentType,
+      [...entries].sort((a, b) => b.lastUsedAt - a.lastUsedAt)
+    ]).filter(([, entries]) => entries.length > 0).sort((a, b) => b[1][0].lastUsedAt - a[1][0].lastUsedAt).map(([agentType, entries]) => [
+      `- ${agentType}: ${entries.map((entry) => `${entry.alias} ${entry.label}`).join("; ")}`,
+      ...entries.map((entry) => [
+        entry,
+        formatContextFiles(entry.contextFiles, {
+          minLines: this.readContextMinLines,
+          maxFiles: this.readContextMaxFiles
+        })
+      ]).filter(([, context]) => context.length > 0).map(([entry, context]) => `  Context read by ${entry.alias}: ${context}`)
+    ].join(`
+`));
+    if (lines.length === 0)
+      return;
+    return [
+      "### Resumable Sessions",
+      "Reuse only for clear continuation of the same thread. Otherwise start fresh.",
+      "",
+      ...lines
+    ].join(`
+`);
+  }
+  getAgentGroup(parentSessionId, agentType, create) {
+    let groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups && create) {
+      groups = new Map;
+      this.sessionsByParent.set(parentSessionId, groups);
+    }
+    let group = groups?.get(agentType);
+    if (!group && create && groups) {
+      group = [];
+      groups.set(agentType, group);
+    }
+    return group;
+  }
+  setAgentGroup(parentSessionId, agentType, entries) {
+    const groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups)
+      return;
+    if (entries.length === 0) {
+      groups.delete(agentType);
+      if (groups.size === 0) {
+        this.sessionsByParent.delete(parentSessionId);
+        this.nextAliasIndexByParent.delete(parentSessionId);
+      }
+      return;
+    }
+    groups.set(agentType, entries);
+  }
+  nextAlias(parentSessionId, agentType) {
+    let counters = this.nextAliasIndexByParent.get(parentSessionId);
+    if (!counters) {
+      counters = new Map;
+      this.nextAliasIndexByParent.set(parentSessionId, counters);
+    }
+    const next = (counters.get(agentType) ?? 0) + 1;
+    counters.set(agentType, next);
+    return `${aliasPrefix(agentType)}-${next}`;
+  }
+  trimGroup(group) {
+    group.sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+    if (group.length > this.maxSessionsPerAgent) {
+      group.length = this.maxSessionsPerAgent;
+    }
+  }
+  trimContextFiles(entry) {
+    if (this.readContextMaxFiles === 0) {
+      entry.contextFiles = [];
+      return;
+    }
+    entry.contextFiles = entry.contextFiles.filter((file) => file.lineCount >= this.readContextMinLines).sort((a, b) => b.lastReadAt - a.lastReadAt).slice(0, this.readContextMaxFiles + 1);
+  }
+  nextOrder() {
+    this.orderCounter += 1;
+    return this.orderCounter;
+  }
+}
+function formatContextFiles(files, options) {
+  const eligible = files.filter((file) => file.lineCount >= options.minLines).sort((a, b) => b.lastReadAt - a.lastReadAt);
+  const shown = eligible.slice(0, options.maxFiles);
+  const rest = eligible.length - shown.length;
+  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";
@@ -22345,6 +22626,17 @@ ${allowedEntries.map((entry) => entry.block).join(`
   });
 }
 function createFilterAvailableSkillsHook(_ctx, config) {
+  const permissionRulesByAgent = new Map;
+  const getPermissionRules = (agentName) => {
+    const cached = permissionRulesByAgent.get(agentName);
+    if (cached) {
+      return cached;
+    }
+    const configuredSkills = getAgentOverride(config, agentName)?.skills;
+    const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+    permissionRulesByAgent.set(agentName, permissionRules);
+    return permissionRules;
+  };
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
       const { messages } = output;
@@ -22352,8 +22644,7 @@ function createFilterAvailableSkillsHook(_ctx, config) {
         return;
       }
       const agentName = getCurrentAgent(messages);
-      const configuredSkills = getAgentOverride(config, agentName)?.skills;
-      const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+      const permissionRules = getPermissionRules(agentName);
       for (const message of messages) {
         for (const part of message.parts) {
           if (part.type !== "text" || !part.text || !part.text.includes("<available_skills>")) {
@@ -22372,6 +22663,8 @@ var RATE_LIMIT_PATTERNS = [
   /too many requests/i,
   /quota.?exceeded/i,
   /usage.?exceeded/i,
+  /ExceededBudget/i,
+  /over.?budget/i,
   /usage limit/i,
   /overloaded/i,
   /resource.?exhausted/i,
@@ -22450,7 +22743,7 @@ class ForegroundFallbackManager {
         if (!props?.sessionID || props.status?.type !== "retry")
           break;
         const msg = props.status.message?.toLowerCase() ?? "";
-        if (msg.includes("rate limit") || msg.includes("usage limit") || msg.includes("usage exceeded") || msg.includes("quota exceeded") || msg.includes("high concurrency") || msg.includes("reduce concurrency")) {
+        if (msg.includes("rate limit") || msg.includes("usage limit") || msg.includes("usage exceeded") || msg.includes("quota exceeded") || msg.includes("exceededbudget") || msg.includes("over budget") || msg.includes("high concurrency") || msg.includes("reduce concurrency")) {
           await this.tryFallback(props.sessionID);
         }
         break;
@@ -22704,7 +22997,21 @@ function processImageAttachments(args) {
   const observerEnabled = !disabledAgents.has("observer");
   if (!observerEnabled)
     return;
+  const messagesWithImages = [];
+  for (const msg of messages) {
+    if (msg.info.role !== "user")
+      continue;
+    const imageParts = msg.parts.filter(isImagePart);
+    if (imageParts.length > 0) {
+      messagesWithImages.push({ msg, imageParts });
+    }
+  }
   const saveDir = join7(workDir, ".opencode", "images");
+  if (messagesWithImages.length === 0) {
+    if (existsSync4(saveDir))
+      cleanupAllSessions(saveDir);
+    return;
+  }
   const gitignorePath = join7(workDir, ".opencode", ".gitignore");
   try {
     mkdirSync2(saveDir, { recursive: true });
@@ -22715,12 +23022,7 @@ function processImageAttachments(args) {
     log2(`[image-hook] failed to create image directory: ${e}`);
   }
   cleanupAllSessions(saveDir);
-  for (const msg of messages) {
-    if (msg.info.role !== "user")
-      continue;
-    const imageParts = msg.parts.filter(isImagePart);
-    if (imageParts.length === 0)
-      continue;
+  for (const { msg, imageParts } of messagesWithImages) {
     const sessionSubdir = msg.info.sessionID ? sanitizeFilename(msg.info.sessionID) : undefined;
     const targetDir = sessionSubdir ? join7(saveDir, sessionSubdir) : saveDir;
     try {
@@ -22880,6 +23182,255 @@ function createPostFileToolNudgeHook(options = {}) {
     }
   };
 }
+// src/hooks/task-session-manager/index.ts
+import path8 from "node:path";
+var AGENT_NAME_SET = new Set([
+  "orchestrator",
+  "oracle",
+  "designer",
+  "explorer",
+  "librarian",
+  "fixer",
+  "observer",
+  "council",
+  "councillor"
+]);
+var MAX_PENDING_TASK_CALLS = 100;
+function isAgentName(value) {
+  return typeof value === "string" && AGENT_NAME_SET.has(value);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractPath(output) {
+  return /<path>([^<]+)<\/path>/.exec(output)?.[1];
+}
+function normalizePath(root, file) {
+  const relative = path8.relative(root, file);
+  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    return file;
+  }
+  return relative;
+}
+function extractReadFiles(root, output) {
+  if (typeof output.output !== "string")
+    return [];
+  const file = extractPath(output.output);
+  if (!file)
+    return [];
+  return [
+    {
+      path: normalizePath(root, file),
+      lineCount: countReadLines(output.output).length,
+      lineNumbers: countReadLines(output.output),
+      lastReadAt: Date.now()
+    }
+  ];
+}
+function countReadLines(output) {
+  const lines = new Set;
+  for (const match of output.matchAll(/^([0-9]+):/gm)) {
+    lines.add(Number(match[1]));
+  }
+  return [...lines];
+}
+function createTaskSessionManagerHook(_ctx, options) {
+  const sessionManager = new SessionManager(options.maxSessionsPerAgent, {
+    readContextMinLines: options.readContextMinLines,
+    readContextMaxFiles: options.readContextMaxFiles
+  });
+  const pendingCalls = new Map;
+  const pendingCallOrder = [];
+  const contextByTask = new Map;
+  const pendingManagedTaskIds = new Set;
+  function addTaskContext(taskId, files) {
+    if (files.length === 0)
+      return;
+    let context = contextByTask.get(taskId);
+    if (!context) {
+      context = new Map;
+      contextByTask.set(taskId, context);
+    }
+    for (const file of files) {
+      const pending = context.get(file.path) ?? {
+        path: file.path,
+        lines: new Set,
+        lastReadAt: file.lastReadAt
+      };
+      for (const line of file.lineNumbers ?? []) {
+        pending.lines.add(line);
+      }
+      pending.lastReadAt = Math.max(pending.lastReadAt, file.lastReadAt);
+      context.set(file.path, pending);
+    }
+    sessionManager.addContext(taskId, contextFilesForPrompt(context));
+  }
+  function contextFilesForPrompt(context) {
+    if (!context)
+      return [];
+    return [...context.values()].map((file) => ({
+      path: file.path,
+      lineCount: file.lines.size,
+      lastReadAt: file.lastReadAt
+    }));
+  }
+  function canTrackTaskContext(taskId) {
+    return pendingManagedTaskIds.has(taskId) || sessionManager.taskIds().has(taskId);
+  }
+  function pruneContext() {
+    const remembered = sessionManager.taskIds();
+    for (const taskId of contextByTask.keys()) {
+      if (!pendingManagedTaskIds.has(taskId) && !remembered.has(taskId)) {
+        contextByTask.delete(taskId);
+      }
+    }
+  }
+  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"));
+  }
+  function rememberPendingCall(call) {
+    const existingIndex = pendingCallOrder.indexOf(call.callId);
+    if (existingIndex >= 0) {
+      pendingCallOrder.splice(existingIndex, 1);
+    }
+    pendingCalls.set(call.callId, call);
+    pendingCallOrder.push(call.callId);
+    while (pendingCallOrder.length > MAX_PENDING_TASK_CALLS) {
+      const evictedCallId = pendingCallOrder.shift();
+      if (!evictedCallId) {
+        break;
+      }
+      pendingCalls.delete(evictedCallId);
+    }
+  }
+  function takePendingCall(callId) {
+    if (!callId)
+      return;
+    const pending = pendingCalls.get(callId);
+    pendingCalls.delete(callId);
+    const orderIndex = pendingCallOrder.indexOf(callId);
+    if (orderIndex >= 0) {
+      pendingCallOrder.splice(orderIndex, 1);
+    }
+    return pending;
+  }
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool.toLowerCase() !== "task")
+        return;
+      if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
+        return;
+      }
+      if (!isObjectRecord(output.args))
+        return;
+      const args = output.args;
+      if (!isAgentName(args.subagent_type))
+        return;
+      const label = deriveTaskSessionLabel({
+        description: typeof args.description === "string" ? args.description : undefined,
+        prompt: typeof args.prompt === "string" ? args.prompt : undefined,
+        agentType: args.subagent_type
+      });
+      if (input.callID) {
+        rememberPendingCall({
+          callId: input.callID,
+          parentSessionId: input.sessionID,
+          agentType: args.subagent_type,
+          label
+        });
+      }
+      if (typeof args.task_id !== "string" || args.task_id.trim() === "") {
+        return;
+      }
+      const requested = args.task_id.trim();
+      const remembered = sessionManager.resolve(input.sessionID, args.subagent_type, requested);
+      if (!remembered) {
+        delete args.task_id;
+        return;
+      }
+      args.task_id = remembered.taskId;
+      pendingManagedTaskIds.add(remembered.taskId);
+      sessionManager.markUsed(input.sessionID, args.subagent_type, remembered.taskId);
+      if (input.callID) {
+        rememberPendingCall({
+          callId: input.callID,
+          parentSessionId: input.sessionID,
+          agentType: args.subagent_type,
+          label,
+          resumedTaskId: remembered.taskId
+        });
+      }
+    },
+    "tool.execute.after": async (input, output) => {
+      if (input.tool.toLowerCase() === "read") {
+        if (input.sessionID && canTrackTaskContext(input.sessionID)) {
+          addTaskContext(input.sessionID, extractReadFiles(_ctx.directory, output));
+        }
+        return;
+      }
+      if (input.tool.toLowerCase() !== "task")
+        return;
+      const pending = takePendingCall(input.callID);
+      if (!pending || typeof output.output !== "string")
+        return;
+      const taskId = parseTaskIdFromTaskOutput(output.output);
+      if (!taskId) {
+        if (pending.resumedTaskId && isMissingRememberedSessionError(output.output)) {
+          sessionManager.drop(pending.parentSessionId, pending.agentType, pending.resumedTaskId);
+        }
+        return;
+      }
+      if (pending.resumedTaskId && pending.resumedTaskId !== taskId) {
+        sessionManager.drop(pending.parentSessionId, pending.agentType, pending.resumedTaskId);
+      }
+      sessionManager.remember({
+        parentSessionId: pending.parentSessionId,
+        taskId,
+        agentType: pending.agentType,
+        label: pending.label
+      });
+      pendingManagedTaskIds.delete(taskId);
+      const contextFiles = contextFilesForPrompt(contextByTask.get(taskId));
+      sessionManager.addContext(taskId, contextFiles);
+      pruneContext();
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
+        return;
+      }
+      const reminder = sessionManager.formatForPrompt(input.sessionID);
+      if (!reminder)
+        return;
+      output.system.push(reminder);
+    },
+    event: async (input) => {
+      if (input.event.type === "session.created") {
+        const info = input.event.properties?.info;
+        if (info?.id && info.parentID && options.shouldManageSession(info.parentID)) {
+          pendingManagedTaskIds.add(info.id);
+        }
+        return;
+      }
+      if (input.event.type !== "session.deleted")
+        return;
+      const sessionId = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+      if (!sessionId)
+        return;
+      sessionManager.clearParent(sessionId);
+      sessionManager.dropTask(sessionId);
+      contextByTask.delete(sessionId);
+      pendingManagedTaskIds.delete(sessionId);
+      pruneContext();
+      for (const [callId, pending] of pendingCalls.entries()) {
+        if (pending.parentSessionId !== sessionId) {
+          continue;
+        }
+        takePendingCall(callId);
+      }
+    }
+  };
+}
 // src/hooks/todo-continuation/index.ts
 import { tool } from "@opencode-ai/plugin/tool";
 
@@ -23542,7 +24093,7 @@ function createTodoContinuationHook(ctx, config) {
   };
 }
 // src/interview/manager.ts
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/interview/dashboard.ts
 import crypto from "node:crypto";
@@ -23552,27 +24103,27 @@ import {
   createServer
 } from "node:http";
 import os3 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import { URL as URL2 } from "node:url";
 
 // src/interview/document.ts
 import * as fsSync from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var DEFAULT_OUTPUT_FOLDER = "interview";
 function normalizeOutputFolder(outputFolder) {
   const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
   return normalized || DEFAULT_OUTPUT_FOLDER;
 }
 function createInterviewDirectoryPath(directory, outputFolder) {
-  return path8.join(directory, normalizeOutputFolder(outputFolder));
+  return path9.join(directory, normalizeOutputFolder(outputFolder));
 }
 function createInterviewFilePath(directory, outputFolder, idea) {
   const fileName = `${slugify(idea) || "interview"}.md`;
-  return path8.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+  return path9.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
 }
 function relativeInterviewPath(directory, filePath) {
-  return path8.relative(directory, filePath) || path8.basename(filePath);
+  return path9.relative(directory, filePath) || path9.basename(filePath);
 }
 function resolveExistingInterviewPath(directory, outputFolder, value) {
   const trimmed = value.trim();
@@ -23581,22 +24132,22 @@ function resolveExistingInterviewPath(directory, outputFolder, value) {
   }
   const outputDir = createInterviewDirectoryPath(directory, outputFolder);
   const candidates = new Set;
-  const resolvedRoot = path8.resolve(directory);
-  if (path8.isAbsolute(trimmed)) {
+  const resolvedRoot = path9.resolve(directory);
+  if (path9.isAbsolute(trimmed)) {
     candidates.add(trimmed);
   } else {
-    candidates.add(path8.resolve(directory, trimmed));
-    candidates.add(path8.join(outputDir, trimmed));
+    candidates.add(path9.resolve(directory, trimmed));
+    candidates.add(path9.join(outputDir, trimmed));
     if (!trimmed.endsWith(".md")) {
-      candidates.add(path8.join(outputDir, `${trimmed}.md`));
+      candidates.add(path9.join(outputDir, `${trimmed}.md`));
     }
   }
   for (const candidate of candidates) {
-    if (path8.extname(candidate) !== ".md") {
+    if (path9.extname(candidate) !== ".md") {
       continue;
     }
-    const resolved = path8.resolve(candidate);
-    if (!resolved.startsWith(resolvedRoot + path8.sep) && resolved !== resolvedRoot) {
+    const resolved = path9.resolve(candidate);
+    if (!resolved.startsWith(resolvedRoot + path9.sep) && resolved !== resolvedRoot) {
       continue;
     }
     if (fsSync.existsSync(candidate)) {
@@ -23676,7 +24227,7 @@ function parseFrontmatter(content) {
   return result;
 }
 async function ensureInterviewFile(record) {
-  await fs6.mkdir(path8.dirname(record.markdownPath), { recursive: true });
+  await fs6.mkdir(path9.dirname(record.markdownPath), { recursive: true });
   try {
     await fs6.access(record.markdownPath);
   } catch {
@@ -23764,6 +24315,7 @@ async function readJsonBody(request) {
 }
 
 // src/interview/ui.ts
+var BRAND_LOGO_URL = "https://ohmyopencodeslim.com/android-chrome-512x512.png";
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
@@ -23861,12 +24413,8 @@ function sharedStyles() {
       }
       .footer { margin-top: 32px; text-align: center; font-size: 13px; color: rgba(255,255,255,0.4); }`;
 }
-function brandSvg(size) {
-  return `<svg class="brand-mark" viewBox="0 0 144 144" role="img" aria-label="Oh My Opencode Slim" style="width:${size}px;height:${size}px">
-          <rect x="12" y="12" width="120" height="120" rx="32" fill="rgba(255,255,255,0.08)" stroke="rgba(255,255,255,0.18)" stroke-width="2"/>
-          <path d="M50 48h18c16 0 26 10 26 24s-10 24-26 24H50z" fill="none" stroke="white" stroke-width="8" stroke-linecap="round" stroke-linejoin="round"/>
-          <path d="M74 48h20c10 0 18 8 18 18v12c0 10-8 18-18 18H74" fill="none" stroke="white" stroke-width="8" stroke-linecap="round" stroke-linejoin="round" opacity="0.65"/>
-        </svg>`;
+function brandImage(size) {
+  return `<img class="brand-mark" src="${BRAND_LOGO_URL}" alt="Oh My Opencode Slim" width="${size}" height="${size}" />`;
 }
 function renderDashboardPage(interviews, files, outputFolder) {
   const activeHtml = interviews.length === 0 ? "" : interviews.map((item) => {
@@ -24075,7 +24623,7 @@ function renderDashboardPage(interviews, files, outputFolder) {
   <body>
     <div class="wrap">
       <div class="brand-header">
-        ${brandSvg(96)}
+        ${brandImage(96)}
         <h1>Interviews</h1>
         <p class="muted">${totalCount} item${totalCount === 1 ? "" : "s"}</p>
       </div>
@@ -24276,6 +24824,37 @@ function renderInterviewPage(interviewId, resumeSlug) {
       }
       
       .options { display: flex; flex-direction: column; gap: 10px; margin-bottom: 20px; }
+      .question-hint {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin: -4px 0 16px;
+        color: rgba(255,255,255,0.5);
+        font-size: 13px;
+        line-height: 1.5;
+        transition: color 0.2s ease;
+      }
+      .active-question .question-hint {
+        color: rgba(255,255,255,0.78);
+      }
+      .hint-chip {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        padding: 4px 10px;
+        border-radius: 999px;
+        background: rgba(255,255,255,0.06);
+        border: 1px solid rgba(255,255,255,0.08);
+      }
+      .hint-chip kbd {
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        font-size: 12px;
+        padding: 2px 6px;
+        border-radius: 6px;
+        background: rgba(255,255,255,0.12);
+        border: 1px solid rgba(255,255,255,0.08);
+        color: rgba(255,255,255,0.95);
+      }
       
       .option { 
         border: 1px solid rgba(255,255,255,0.1); 
@@ -24555,7 +25134,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
     <div class="wrap">
       <a href="/" class="back-link">← All Interviews</a>
       <div class="brand-header">
-        ${brandSvg(144)}
+        ${brandImage(144)}
       </div>
       <h1 id="idea">Connecting...</h1>
       <p class="muted" id="summary">Preparing interview session</p>
@@ -24596,7 +25175,15 @@ function renderInterviewPage(interviewId, resumeSlug) {
       ${clipboardHelperJs()}
       const interviewId = ${JSON.stringify(interviewId).replace(/</g, "\\u003c")};
       const resumeSlug = ${JSON.stringify(resumeSlug).replace(/</g, "\\u003c")};
-      const state = { data: null, answers: {}, activeQuestionIndex: 0, lastSig: null, customMode: {} };
+      const state = {
+        data: null,
+        answers: {},
+        activeQuestionIndex: 0,
+        lastQuestionIds: [],
+        lastSig: null,
+        customMode: {},
+        isSubmitting: false,
+      };
 
       function updateSubmitButton() {
         const button = document.getElementById('submitButton');
@@ -24609,7 +25196,11 @@ function renderInterviewPage(interviewId, resumeSlug) {
         const allAnswered = questions.every((question) =>
           (state.answers[question.id] || '').trim().length > 0,
         );
-        button.disabled = state.data.isBusy || !questions.length || !allAnswered;
+        button.disabled =
+          state.data.isBusy ||
+          state.isSubmitting ||
+          !questions.length ||
+          !allAnswered;
         const hideSubmit = ['completed', 'session-disconnected'];
         button.style.display = hideSubmit.includes(state.data.mode) ? 'none' : '';
         
@@ -24760,6 +25351,54 @@ function renderInterviewPage(interviewId, resumeSlug) {
          });
       }
 
+      function scrollToActiveQuestion(behavior) {
+        const questions = state.data?.questions || [];
+        const activeQ = questions[state.activeQuestionIndex];
+        if (!activeQ) return;
+
+        const wrapper = document.getElementById('question-' + activeQ.id);
+        if (wrapper) {
+          wrapper.scrollIntoView({ behavior, block: 'center' });
+        }
+      }
+
+      function syncActiveQuestionIndex(questions) {
+        if (!questions.length) {
+          state.activeQuestionIndex = 0;
+          state.lastQuestionIds = [];
+          return;
+        }
+
+        const nextQuestionIds = questions.map((question) => question.id);
+        const previousQuestionIds = state.lastQuestionIds || [];
+        const activeQuestionId = previousQuestionIds[state.activeQuestionIndex];
+        const nextActiveIndex = activeQuestionId
+          ? nextQuestionIds.indexOf(activeQuestionId)
+          : -1;
+
+        if (nextActiveIndex >= 0) {
+          state.activeQuestionIndex = nextActiveIndex;
+        } else {
+          state.activeQuestionIndex = 0;
+        }
+
+        state.lastQuestionIds = nextQuestionIds;
+      }
+
+      function isTextEntryTarget(target) {
+        return target &&
+          (target.tagName === 'TEXTAREA' ||
+            target.tagName === 'INPUT' ||
+            target.isContentEditable);
+      }
+
+      function isShortcutBlockedTarget(target) {
+        if (!target) return false;
+        return !!target.closest(
+          'button, a, select, summary, textarea, input, [contenteditable="true"]',
+        );
+      }
+
       document.addEventListener('keydown', (e) => {
         const isSubmitShortcut =
           (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) ||
@@ -24773,12 +25412,41 @@ function renderInterviewPage(interviewId, resumeSlug) {
           return;
         }
 
-        if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') return;
+        if (isTextEntryTarget(e.target)) return;
         if (e.ctrlKey || e.metaKey || e.altKey) return;
 
         const questions = state.data?.questions || [];
         if (!questions.length) return;
 
+        if (e.key === 'Enter') {
+          if (e.repeat) {
+            e.preventDefault();
+            return;
+          }
+          if (isShortcutBlockedTarget(e.target)) return;
+          if (state.data.isBusy || state.isSubmitting) return;
+
+          const activeQ = questions[state.activeQuestionIndex];
+          if (!activeQ) return;
+
+          const answer = (state.answers[activeQ.id] || '').trim();
+          if (!answer) return;
+
+          const isLastQuestion =
+            state.activeQuestionIndex === questions.length - 1;
+          if (isLastQuestion) {
+            const submitBtn = document.getElementById('submitButton');
+            if (submitBtn && !submitBtn.disabled) {
+              submitBtn.click();
+            }
+          } else {
+            advanceToNextQuestion(activeQ.id);
+          }
+
+          e.preventDefault();
+          return;
+        }
+
          const num = parseInt(e.key, 10);
          if (num >= 1 && num <= 9) {
           const activeQ = questions[state.activeQuestionIndex];
@@ -24946,6 +25614,10 @@ function renderInterviewPage(interviewId, resumeSlug) {
       function renderQuestions(questions) {
         const sig = JSON.stringify([questions, state.data?.mode]);
         const container = document.getElementById('questions');
+        const previousActiveQuestionId =
+          state.lastQuestionIds[state.activeQuestionIndex];
+
+        syncActiveQuestionIndex(questions);
 
         if (state.lastSig === sig) {
           questions.forEach((q) => updateOptionsDOM(q.id));
@@ -24986,6 +25658,15 @@ function renderInterviewPage(interviewId, resumeSlug) {
           wrapper.appendChild(title);
 
           const predefined = question.options || [];
+          if (predefined.length) {
+            const hint = document.createElement('div');
+            hint.className = 'question-hint';
+            hint.innerHTML =
+              '<span class="hint-chip"><kbd>1-9</kbd><span>Choose an option</span></span>' +
+              '<span class="hint-chip"><kbd>Enter</kbd><span>Accept selected answer</span></span>';
+            wrapper.appendChild(hint);
+          }
+
           if (predefined.length) {
             const options = document.createElement('div');
             options.className = 'options';
@@ -25021,6 +25702,13 @@ function renderInterviewPage(interviewId, resumeSlug) {
         
         updateActiveQuestionFocus();
         questions.forEach(q => updateOptionsDOM(q.id));
+        const currentActiveQuestionId = questions[state.activeQuestionIndex]?.id;
+        if (
+          questions.length > 0 &&
+          previousActiveQuestionId !== currentActiveQuestionId
+        ) {
+          scrollToActiveQuestion('smooth');
+        }
       }
 
       function render(data) {
@@ -25094,7 +25782,8 @@ function renderInterviewPage(interviewId, resumeSlug) {
       }
 
       document.getElementById('submitButton').addEventListener('click', async () => {
-        if (!state.data) return;
+        if (!state.data || state.isSubmitting) return;
+        document.getElementById('submitButton').blur();
         const answers = (state.data.questions || []).map((question) => {
           return {
             questionId: question.id,
@@ -25102,6 +25791,9 @@ function renderInterviewPage(interviewId, resumeSlug) {
           };
         });
 
+        state.isSubmitting = true;
+        updateSubmitButton();
+
         const overlay = document.getElementById('loadingOverlay');
         const overlayText = document.getElementById('loadingText');
         overlay.classList.add('active');
@@ -25119,6 +25811,8 @@ function renderInterviewPage(interviewId, resumeSlug) {
         } catch (err) {
           document.getElementById('submitStatus').textContent = 'Error submitting answers.';
         }
+        state.isSubmitting = false;
+        updateSubmitButton();
         try {
           await refresh();
         } catch (_error) {
@@ -25203,12 +25897,12 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
 // src/interview/dashboard.ts
 function getAuthFilePath(port) {
-  const dataHome = process.env.XDG_DATA_HOME || path9.join(os3.homedir(), ".local", "share");
-  return path9.join(dataHome, "opencode", `.dashboard-${port}.json`);
+  const dataHome = process.env.XDG_DATA_HOME || path10.join(os3.homedir(), ".local", "share");
+  return path10.join(dataHome, "opencode", `.dashboard-${port}.json`);
 }
 function writeAuthFile(port, token) {
   const filePath = getAuthFilePath(port);
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   try {
     fsSync2.mkdirSync(dir, { recursive: true });
   } catch {}
@@ -25345,7 +26039,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     const items = [];
     for (const dir of directories) {
-      const interviewDir = path9.join(dir, config.outputFolder);
+      const interviewDir = path10.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -25357,7 +26051,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path9.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -25383,7 +26077,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     let rebuilt = 0;
     for (const dir of directories) {
-      const interviewDir = path9.join(dir, config.outputFolder);
+      const interviewDir = path10.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -25395,7 +26089,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path9.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -25421,7 +26115,7 @@ function createDashboardServer(config) {
           questions: [],
           pendingAnswers: null,
           lastUpdatedAt: fm.updatedAt ? new Date(fm.updatedAt).getTime() : Date.now(),
-          filePath: path9.join(interviewDir, entry),
+          filePath: path10.join(interviewDir, entry),
           nudgeAction: null
         });
         if (!sessions.has(fm.sessionID)) {
@@ -25685,7 +26379,7 @@ function createDashboardServer(config) {
         const dirs = getKnownDirectories();
         for (const dir of dirs) {
           const slug = extractResumeSlug(interviewId);
-          const candidate = path9.join(dir, config.outputFolder, `${slug}.md`);
+          const candidate = path10.join(dir, config.outputFolder, `${slug}.md`);
           try {
             document = await fs7.readFile(candidate, "utf8");
             markdownPath = candidate;
@@ -26213,7 +26907,7 @@ function createInterviewServer(deps) {
 // src/interview/service.ts
 import { spawn } from "node:child_process";
 import * as fs8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // src/interview/types.ts
 import { z as z3 } from "zod";
@@ -26438,6 +27132,7 @@ function createInterviewService(ctx, config, deps) {
   const activeInterviewIds = new Map;
   const interviewsById = new Map;
   const sessionBusy = new Map;
+  const sessionModel = new Map;
   const browserOpened = new Set;
   let resolveBaseUrl = null;
   let onStateChange = null;
@@ -26479,12 +27174,12 @@ function createInterviewService(ctx, config, deps) {
     if (!newSlug) {
       return;
     }
-    const currentFileName = path10.basename(interview.markdownPath, ".md");
+    const currentFileName = path11.basename(interview.markdownPath, ".md");
     if (currentFileName === newSlug) {
       return;
     }
-    const dir = path10.dirname(interview.markdownPath);
-    const newPath = path10.join(dir, `${newSlug}.md`);
+    const dir = path11.dirname(interview.markdownPath);
+    const newPath = path11.join(dir, `${newSlug}.md`);
     try {
       await fs8.access(newPath);
       return;
@@ -26560,9 +27255,9 @@ function createInterviewService(ctx, config, deps) {
     const messages = await loadMessages(sessionID);
     const title = extractTitle(document);
     const record = {
-      id: `${Date.now()}-${++idCounter}-${slugify(path10.basename(markdownPath, ".md")) || "interview"}`,
+      id: `${Date.now()}-${++idCounter}-${slugify(path11.basename(markdownPath, ".md")) || "interview"}`,
       sessionID,
-      idea: title || path10.basename(markdownPath, ".md"),
+      idea: title || path11.basename(markdownPath, ".md"),
       markdownPath,
       createdAt: nowIso(),
       status: "active",
@@ -26693,10 +27388,12 @@ function createInterviewService(ctx, config, deps) {
       }
       await appendInterviewAnswers(interview, state.questions, answers);
       const prompt = buildAnswerPrompt(answers, state.questions, maxQuestions);
+      const model = sessionModel.get(interview.sessionID);
       await ctx.client.session.promptAsync({
         path: { id: interview.sessionID },
         body: {
-          parts: [createInternalAgentTextPart(prompt)]
+          parts: [createInternalAgentTextPart(prompt)],
+          ...model ? { model: parseModelReference(model) ?? undefined } : {}
         }
       });
       promptSent = true;
@@ -26746,12 +27443,23 @@ function createInterviewService(ctx, config, deps) {
       }
       return;
     }
+    if (event.type === "message.updated") {
+      const info = properties;
+      const sessionID = info?.info?.sessionID;
+      const providerID = info?.info?.providerID;
+      const modelID = info?.info?.modelID;
+      if (sessionID && providerID && modelID) {
+        sessionModel.set(sessionID, `${providerID}/${modelID}`);
+      }
+      return;
+    }
     if (event.type === "session.deleted") {
       const deletedSessionId = (properties.info?.id ?? properties.sessionID) || null;
       if (!deletedSessionId) {
         return;
       }
       sessionBusy.delete(deletedSessionId);
+      sessionModel.delete(deletedSessionId);
       const interviewId = activeInterviewIds.get(deletedSessionId);
       if (!interviewId) {
         return;
@@ -26776,7 +27484,7 @@ function createInterviewService(ctx, config, deps) {
       return fileCache.items;
     }
     const outputDir = createInterviewDirectoryPath(ctx.directory, outputFolder);
-    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path10.resolve(i.markdownPath)));
+    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path11.resolve(i.markdownPath)));
     let entries;
     try {
       entries = await fs8.readdir(outputDir);
@@ -26787,8 +27495,8 @@ function createInterviewService(ctx, config, deps) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const fullPath = path10.join(outputDir, entry);
-      if (activePaths.has(path10.resolve(fullPath)))
+      const fullPath = path11.join(outputDir, entry);
+      if (activePaths.has(path11.resolve(fullPath)))
         continue;
       let content;
       try {
@@ -26848,10 +27556,12 @@ function createInterviewService(ctx, config, deps) {
         ].join(`
 `);
       }
+      const model = sessionModel.get(interview.sessionID);
       await ctx.client.session.promptAsync({
         path: { id: interview.sessionID },
         body: {
-          parts: [createInternalAgentTextPart(prompt)]
+          parts: [createInternalAgentTextPart(prompt)],
+          ...model ? { model: parseModelReference(model) ?? undefined } : {}
         }
       });
       promptSent = true;
@@ -26885,7 +27595,7 @@ function createInterviewManager(ctx, config) {
   const outputFolder = interviewConfig?.outputFolder ?? "interview";
   if (!dashboardEnabled) {
     const service2 = createInterviewService(ctx, interviewConfig);
-    const resolvedOutputPath = path11.join(ctx.directory, outputFolder);
+    const resolvedOutputPath = path12.join(ctx.directory, outputFolder);
     const server = createInterviewServer({
       getState: async (interviewId) => service2.getInterviewState(interviewId),
       listInterviewFiles: async () => service2.listInterviewFiles(),
@@ -26990,7 +27700,7 @@ function createInterviewManager(ctx, config) {
               listInterviews: () => service.listInterviews(),
               submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
               handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
-              outputFolder: path11.join(ctx.directory, outputFolder),
+              outputFolder: path12.join(ctx.directory, outputFolder),
               port: 0
             });
             service.setBaseUrlResolver(() => perSessionServer.ensureStarted());
@@ -27430,23 +28140,23 @@ class TmuxMultiplexer {
         return null;
       }
       const stdout = await proc.stdout();
-      const path12 = stdout.trim().split(`
+      const path13 = stdout.trim().split(`
 `)[0];
-      if (!path12) {
+      if (!path13) {
         log("[tmux] findBinary: no path in output");
         return null;
       }
-      const verifyProc = crossSpawn([path12, "-V"], {
+      const verifyProc = crossSpawn([path13, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
       const verifyExit = await verifyProc.exited;
       if (verifyExit !== 0) {
-        log("[tmux] findBinary: tmux -V failed", { path: path12, verifyExit });
+        log("[tmux] findBinary: tmux -V failed", { path: path13, verifyExit });
         return null;
       }
-      log("[tmux] findBinary: found", { path: path12 });
-      return path12;
+      log("[tmux] findBinary: found", { path: path13 });
+      return path13;
     } catch (err) {
       log("[tmux] findBinary: exception", { error: String(err) });
       return null;
@@ -27825,6 +28535,8 @@ class MultiplexerSessionManager {
   directory;
   multiplexer = null;
   sessions = new Map;
+  knownSessions = new Map;
+  spawningSessions = new Set;
   pollInterval;
   enabled = false;
   constructor(ctx, config) {
@@ -27853,45 +28565,59 @@ class MultiplexerSessionManager {
     const parentId = info.parentID;
     const title = info.title ?? "Subagent";
     const directory = info.directory ?? this.directory;
-    if (this.sessions.has(sessionId)) {
-      log("[multiplexer-session-manager] session already tracked", {
+    this.knownSessions.set(sessionId, {
+      parentId,
+      title,
+      directory
+    });
+    if (this.isTrackedOrSpawning(sessionId)) {
+      log("[multiplexer-session-manager] session already tracked or spawning", {
         sessionId
       });
       return;
     }
-    const serverRunning = await isServerRunning(this.serverUrl);
-    if (!serverRunning) {
-      log("[multiplexer-session-manager] server not running, skipping", {
-        serverUrl: this.serverUrl
-      });
-      return;
-    }
-    log("[multiplexer-session-manager] child session created, spawning pane", {
-      sessionId,
-      parentId,
-      title
-    });
-    const paneResult = await this.multiplexer.spawnPane(sessionId, title, this.serverUrl, directory).catch((err) => {
-      log("[multiplexer-session-manager] failed to spawn pane", {
-        error: String(err)
-      });
-      return { success: false, paneId: undefined };
-    });
-    if (paneResult.success && paneResult.paneId) {
-      const now = Date.now();
-      this.sessions.set(sessionId, {
+    this.spawningSessions.add(sessionId);
+    try {
+      const serverRunning = await isServerRunning(this.serverUrl);
+      if (!serverRunning) {
+        log("[multiplexer-session-manager] server not running, skipping", {
+          serverUrl: this.serverUrl
+        });
+        return;
+      }
+      if (this.sessions.has(sessionId)) {
+        return;
+      }
+      log("[multiplexer-session-manager] child session created, spawning pane", {
         sessionId,
-        paneId: paneResult.paneId,
         parentId,
-        title,
-        createdAt: now,
-        lastSeenAt: now
+        title
       });
-      log("[multiplexer-session-manager] pane spawned", {
-        sessionId,
-        paneId: paneResult.paneId
+      const paneResult = await this.multiplexer.spawnPane(sessionId, title, this.serverUrl, directory).catch((err) => {
+        log("[multiplexer-session-manager] failed to spawn pane", {
+          error: String(err)
+        });
+        return { success: false, paneId: undefined };
       });
-      this.startPolling();
+      if (paneResult.success && paneResult.paneId) {
+        const now = Date.now();
+        this.sessions.set(sessionId, {
+          sessionId,
+          paneId: paneResult.paneId,
+          parentId,
+          title,
+          directory,
+          createdAt: now,
+          lastSeenAt: now
+        });
+        log("[multiplexer-session-manager] pane spawned", {
+          sessionId,
+          paneId: paneResult.paneId
+        });
+        this.startPolling();
+      }
+    } finally {
+      this.spawningSessions.delete(sessionId);
     }
   }
   async onSessionStatus(event) {
@@ -27904,6 +28630,10 @@ class MultiplexerSessionManager {
       return;
     if (event.properties?.status?.type === "idle") {
       await this.closeSession(sessionId);
+      return;
+    }
+    if (event.properties?.status?.type === "busy") {
+      await this.respawnIfKnown(sessionId);
     }
   }
   async onSessionDeleted(event) {
@@ -27918,6 +28648,7 @@ class MultiplexerSessionManager {
       sessionId
     });
     await this.closeSession(sessionId);
+    this.knownSessions.delete(sessionId);
   }
   startPolling() {
     if (this.pollInterval)
@@ -27978,6 +28709,61 @@ class MultiplexerSessionManager {
       this.stopPolling();
     }
   }
+  async respawnIfKnown(sessionId) {
+    if (!this.enabled || !this.multiplexer)
+      return;
+    if (this.isTrackedOrSpawning(sessionId))
+      return;
+    const known = this.knownSessions.get(sessionId);
+    if (!known)
+      return;
+    this.spawningSessions.add(sessionId);
+    try {
+      const serverRunning = await isServerRunning(this.serverUrl);
+      if (!serverRunning) {
+        log("[multiplexer-session-manager] server not running, skipping busy respawn", {
+          serverUrl: this.serverUrl,
+          sessionId
+        });
+        return;
+      }
+      if (this.sessions.has(sessionId))
+        return;
+      log("[multiplexer-session-manager] child session busy again, respawning pane", {
+        sessionId,
+        parentId: known.parentId,
+        title: known.title
+      });
+      const paneResult = await this.multiplexer.spawnPane(sessionId, known.title, this.serverUrl, known.directory).catch((err) => {
+        log("[multiplexer-session-manager] failed to respawn pane", {
+          error: String(err)
+        });
+        return { success: false, paneId: undefined };
+      });
+      if (!paneResult.success || !paneResult.paneId)
+        return;
+      const now = Date.now();
+      this.sessions.set(sessionId, {
+        sessionId,
+        paneId: paneResult.paneId,
+        parentId: known.parentId,
+        title: known.title,
+        directory: known.directory,
+        createdAt: now,
+        lastSeenAt: now
+      });
+      log("[multiplexer-session-manager] pane respawned on busy", {
+        sessionId,
+        paneId: paneResult.paneId
+      });
+      this.startPolling();
+    } finally {
+      this.spawningSessions.delete(sessionId);
+    }
+  }
+  isTrackedOrSpawning(sessionId) {
+    return this.sessions.has(sessionId) || this.spawningSessions.has(sessionId);
+  }
   async cleanup() {
     this.stopPolling();
     if (this.sessions.size > 0 && this.multiplexer) {
@@ -27992,6 +28778,8 @@ class MultiplexerSessionManager {
       await Promise.all(closePromises);
       this.sessions.clear();
     }
+    this.knownSessions.clear();
+    this.spawningSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -28203,9 +28991,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path12 of homebrewPaths) {
-      if (existsSync7(path12) && isValidBinary(path12)) {
-        return path12;
+    for (const path13 of homebrewPaths) {
+      if (existsSync7(path13) && isValidBinary(path13)) {
+        return path13;
       }
     }
   }
@@ -28222,8 +29010,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path12) {
-  resolvedCliPath = path12;
+function setSgCliPath(path13) {
+  resolvedCliPath = path13;
 }
 var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -28791,14 +29579,14 @@ var BINARY_PREFIXES = [
 var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";
 // src/tools/smartfetch/tool.ts
 import os4 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 import {
   tool as tool4
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -28819,10 +29607,10 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
 async function saveBinary(binaryDir, data, contentType, filename) {
   await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path12.parse(initialName);
+  const parsed = path13.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path12.join(binaryDir, candidateName);
+    const file = path13.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -29476,7 +30264,7 @@ var L = class u2 {
 };
 
 // src/tools/smartfetch/network.ts
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/tools/smartfetch/utils.ts
 var import_readability = __toESM(require_readability(), 1);
@@ -30201,7 +30989,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path13.parse(name);
+  const parsed = path14.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -30373,7 +31161,7 @@ function isInvalidLlmsResult(fetchResult) {
 // src/tools/smartfetch/secondary-model.ts
 import { existsSync as existsSync9 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -30399,7 +31187,7 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path14.join(baseDir, file);
+    const fullPath = path15.join(baseDir, file);
     if (existsSync9(fullPath))
       return fullPath;
   }
@@ -30416,7 +31204,7 @@ async function readOpenCodeConfigFile(configPath) {
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path14.join(directory, ".opencode");
+  const projectDir = path15.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -30577,7 +31365,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z5 = tool4.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path15.join(os4.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path16.join(os4.tmpdir(), "opencode-smartfetch");
   return tool4({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -31099,6 +31887,27 @@ class SubagentDepthTracker {
   }
 }
 
+// src/utils/system-collapse.ts
+function collapseSystemInPlace(system2) {
+  if (system2.length === 0) {
+    return;
+  }
+  if (system2.length === 1) {
+    if (system2[0]) {
+      return;
+    }
+    system2.length = 0;
+    return;
+  }
+  const joined = system2.join(`
+
+`);
+  system2.length = 0;
+  if (joined) {
+    system2.push(joined);
+  }
+}
+
 // src/index.ts
 async function appLog(ctx, level, message) {
   try {
@@ -31128,6 +31937,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   const sessionId = new Date().toISOString().replace(/[-:]/g, "").slice(0, 15);
   initLogger(sessionId);
   let config;
+  let disabledAgents;
   let agentDefs;
   let agents;
   let mcps;
@@ -31148,13 +31958,17 @@ var OhMyOpenCodeLite = async (ctx) => {
   let jsonErrorRecoveryHook;
   let foregroundFallback;
   let todoContinuationHook;
+  let taskSessionManagerHook;
   let interviewManager;
   let presetManager;
   let councilTools;
   let webfetch;
+  let rewriteDisplayNameMentions;
   let toolCount = 0;
   try {
     config = loadPluginConfig(ctx.directory);
+    disabledAgents = getDisabledAgents(config);
+    rewriteDisplayNameMentions = createDisplayNameMentionRewriter(config);
     agentDefs = createAgents(config);
     agents = getAgentConfigs(config);
     modelArrayMap = {};
@@ -31191,7 +32005,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       main_pane_size: config.multiplexer?.main_pane_size ?? 60
     };
     const multiplexer = getMultiplexer(multiplexerConfig);
-    multiplexerEnabled = multiplexerConfig.type !== "none" && multiplexer !== null;
+    multiplexerEnabled = multiplexerConfig.type !== "none" && multiplexer !== null && multiplexer.isInsideSession();
     log("[plugin] initialized with multiplexer config", {
       multiplexerConfig,
       enabled: multiplexerEnabled,
@@ -31207,7 +32021,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig);
     autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
       showStartupToast: config.showStartupToast ?? true,
-      autoUpdate: true
+      autoUpdate: config.autoUpdate ?? true
     });
     phaseReminderHook = createPhaseReminderHook();
     filterAvailableSkillsHook = createFilterAvailableSkillsHook(ctx, config);
@@ -31226,6 +32040,12 @@ var OhMyOpenCodeLite = async (ctx) => {
       autoEnable: config.todoContinuation?.autoEnable ?? false,
       autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4
     });
+    taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
+      maxSessionsPerAgent: config.sessionManager?.maxSessionsPerAgent ?? 2,
+      readContextMinLines: config.sessionManager?.readContextMinLines ?? 10,
+      readContextMaxFiles: config.sessionManager?.readContextMaxFiles ?? 8,
+      shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
+    });
     interviewManager = createInterviewManager(ctx, config);
     presetManager = createPresetManager(ctx, config);
     toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2;
@@ -31401,6 +32221,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionDeleted(event);
       await interviewManager.handleEvent(input);
       await postFileToolNudgeHook.event(input);
+      await taskSessionManagerHook.event(input);
       if (input.event.type === "session.deleted") {
         const props = input.event.properties;
         const sessionID = props?.info?.id ?? props?.sessionID;
@@ -31414,6 +32235,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     },
     "tool.execute.before": async (input, output) => {
       await applyPatchHook["tool.execute.before"](input, output);
+      await taskSessionManagerHook["tool.execute.before"](input, output);
     },
     "command.execute.before": async (input, output) => {
       await todoContinuationHook.handleCommandExecuteBefore(input, output);
@@ -31441,7 +32263,7 @@ var OhMyOpenCodeLite = async (ctx) => {
         const alreadyInjected = output.system.some((s) => typeof s === "string" && s.includes("<Role>") && s.includes("orchestrator"));
         if (!alreadyInjected) {
           const orchestratorDef = agentDefs.find((a) => a.name === "orchestrator");
-          const orchestratorPrompt = typeof orchestratorDef?.config?.prompt === "string" ? orchestratorDef.config.prompt : buildOrchestratorPrompt(getDisabledAgents(config));
+          const orchestratorPrompt = typeof orchestratorDef?.config?.prompt === "string" ? orchestratorDef.config.prompt : buildOrchestratorPrompt(disabledAgents);
           output.system[0] = orchestratorPrompt + (output.system[0] ? `
 
 ${output.system[0]}` : "");
@@ -31449,10 +32271,8 @@ ${output.system[0]}` : "");
       }
       await todoContinuationHook.handleChatSystemTransform(input, output);
       await postFileToolNudgeHook["experimental.chat.system.transform"](input, output);
-      const joined = output.system.join(`
-
-`);
-      output.system = joined ? [joined] : [];
+      await taskSessionManagerHook["experimental.chat.system.transform"](input, output);
+      collapseSystemInPlace(output.system);
     },
     "experimental.chat.messages.transform": async (input, output) => {
       const typedOutput = output;
@@ -31464,13 +32284,13 @@ ${output.system[0]}` : "");
           if (part.type !== "text" || typeof part.text !== "string") {
             continue;
           }
-          part.text = rewriteDisplayNameMentions(config, part.text);
+          part.text = rewriteDisplayNameMentions(part.text);
         }
       }
       processImageAttachments({
         messages: typedOutput.messages,
         workDir: ctx.directory,
-        disabledAgents: getDisabledAgents(config),
+        disabledAgents,
         log
       });
       await todoContinuationHook.handleMessagesTransform({
@@ -31484,6 +32304,7 @@ ${output.system[0]}` : "");
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);
       await todoContinuationHook.handleToolExecuteAfter(input);
       await postFileToolNudgeHook["tool.execute.after"](input, output);
+      await taskSessionManagerHook["tool.execute.after"](input, output);
     }
   };
 };