oh-my-opencode-slim 1.0.0 → 1.0.2

package/dist/index.js

@@ -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;
@@ -18378,13 +18378,15 @@ var CouncilConfigSchema = z.object({
     deprecated.push("master_timeout");
   if (data.master_fallback !== undefined)
     deprecated.push("master_fallback");
+  const legacyMasterModel = typeof data.master === "object" && data.master !== null && "model" in data.master && typeof data.master.model === "string" ? data.master.model : undefined;
   return {
     presets: data.presets,
     timeout: data.timeout,
     default_preset: data.default_preset,
     councillor_execution_mode: data.councillor_execution_mode,
     councillor_retries: data.councillor_retries,
-    _deprecated: deprecated.length > 0 ? deprecated : undefined
+    _deprecated: deprecated.length > 0 ? deprecated : undefined,
+    _legacyMasterModel: legacyMasterModel
   };
 });
 // src/config/loader.ts
@@ -18523,6 +18525,9 @@ 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)
+});
 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)"),
@@ -18564,6 +18569,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(),
@@ -18573,6 +18579,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()
@@ -18658,6 +18665,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)
     };
@@ -18929,6 +18937,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
@@ -18936,6 +18950,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
@@ -19630,6 +19650,13 @@ function createAgents(config) {
     applyDefaultPermissions(agent, override?.skills);
     return agent;
   });
+  const legacyMasterModel = config?.council?._legacyMasterModel;
+  if (legacyMasterModel) {
+    const councilAgent = builtInSubAgents.find((a) => a.name === "council");
+    if (councilAgent && !getAgentOverride(config, "council")?.model && councilAgent.config.model === DEFAULT_MODELS.council) {
+      councilAgent.config.model = legacyMasterModel;
+    }
+  }
   const customSubAgents = protoCustomAgents.map((agent) => {
     const override = getAgentOverride(config, agent.name);
     if (override) {
@@ -19819,17 +19846,22 @@ class CouncilManager {
   depthTracker;
   tmuxEnabled;
   deprecatedFields;
+  legacyMasterModel;
   constructor(ctx, config, depthTracker, tmuxEnabled = false) {
     this.client = ctx.client;
     this.directory = ctx.directory;
     this.config = config;
     this.deprecatedFields = config?.council?._deprecated;
+    this.legacyMasterModel = config?.council?._legacyMasterModel;
     this.depthTracker = depthTracker;
     this.tmuxEnabled = tmuxEnabled;
   }
   getDeprecatedFields() {
     return this.deprecatedFields;
   }
+  getLegacyMasterModel() {
+    return this.legacyMasterModel;
+  }
   async runCouncil(prompt, presetName, parentSessionId) {
     if (this.depthTracker) {
       const parentDepth = this.depthTracker.getDepth(parentSessionId);
@@ -22043,6 +22075,185 @@ function hasInternalInitiatorMarker(part) {
   }
   return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
 }
+// src/utils/session-manager.ts
+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;
+  sessionsByParent = new Map;
+  nextAliasIndexByParent = new Map;
+  orderCounter = 0;
+  constructor(maxSessionsPerAgent) {
+    this.maxSessionsPerAgent = maxSessionsPerAgent;
+  }
+  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,
+      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);
+      }
+    }
+  }
+  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("; ")}`);
+    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;
+    }
+  }
+  nextOrder() {
+    this.orderCounter += 1;
+    return this.orderCounter;
+  }
+}
+// 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";
@@ -22358,6 +22569,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,
@@ -22436,7 +22649,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;
@@ -22613,31 +22826,51 @@ function extFromMime(mime) {
 function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-function cleanupOldImages(dir, saveDir) {
+function cleanupAllSessions(saveDir) {
   const now = Date.now();
-  if (!lastCleanupByDir.has(dir) && existsSync4(dir)) {
-    lastCleanupByDir.set(dir, now);
-  }
-  const lastCleanup = lastCleanupByDir.get(dir) ?? 0;
+  const lastCleanup = lastCleanupByDir.get(saveDir) ?? 0;
   if (now - lastCleanup < CLEANUP_INTERVAL)
     return;
-  lastCleanupByDir.set(dir, now);
+  lastCleanupByDir.set(saveDir, now);
+  const maxAge = 60 * 60 * 1000;
+  const dirsToScan = [];
   try {
-    const maxAge = 60 * 60 * 1000;
-    for (const f of readdirSync2(dir)) {
-      const fp = join7(dir, f);
-      try {
-        if (now - statSync3(fp).mtimeMs > maxAge)
-          unlinkSync2(fp);
-      } catch {}
-    }
-    if (dir !== saveDir) {
-      try {
-        rmdirSync(dir);
-        lastCleanupByDir.delete(dir);
-      } catch {}
+    for (const entry of readdirSync2(saveDir, { withFileTypes: true })) {
+      const fp = join7(saveDir, entry.name);
+      if (entry.isDirectory()) {
+        dirsToScan.push(fp);
+      } else {
+        try {
+          if (now - statSync3(fp).mtimeMs > maxAge)
+            unlinkSync2(fp);
+        } catch {}
+      }
     }
   } catch {}
+  for (const dir of dirsToScan) {
+    try {
+      let isEmpty = true;
+      let allRemoved = true;
+      for (const f of readdirSync2(dir)) {
+        isEmpty = false;
+        const fp = join7(dir, f);
+        try {
+          if (now - statSync3(fp).mtimeMs > maxAge) {
+            unlinkSync2(fp);
+          } else {
+            allRemoved = false;
+          }
+        } catch {
+          allRemoved = false;
+        }
+      }
+      if (!isEmpty && allRemoved) {
+        try {
+          rmdirSync(dir);
+        } catch {}
+      }
+    } catch {}
+  }
 }
 function writeUniqueFile(dir, name, data, log2) {
   const ext = extname(name);
@@ -22680,6 +22913,7 @@ function processImageAttachments(args) {
   } catch (e) {
     log2(`[image-hook] failed to create image directory: ${e}`);
   }
+  cleanupAllSessions(saveDir);
   for (const msg of messages) {
     if (msg.info.role !== "user")
       continue;
@@ -22693,7 +22927,6 @@ function processImageAttachments(args) {
     } catch (e) {
       log2(`[image-hook] failed to create target image directory: ${e}`);
     }
-    cleanupOldImages(targetDir, saveDir);
     const savedPaths = [];
     for (const p of imageParts) {
       const url = p.url;
@@ -22846,6 +23079,154 @@ function createPostFileToolNudgeHook(options = {}) {
     }
   };
 }
+// src/hooks/task-session-manager/index.ts
+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 createTaskSessionManagerHook(_ctx, options) {
+  const sessionManager = new SessionManager(options.maxSessionsPerAgent);
+  const pendingCalls = new Map;
+  const pendingCallOrder = [];
+  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;
+      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() !== "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
+      });
+    },
+    "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.deleted")
+        return;
+      const sessionId = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+      if (!sessionId)
+        return;
+      sessionManager.clearParent(sessionId);
+      sessionManager.dropTask(sessionId);
+      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";
 
@@ -23730,6 +24111,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;");
 }
@@ -23827,12 +24209,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) => {
@@ -24041,7 +24419,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>
@@ -24242,6 +24620,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); 
@@ -24521,7 +24930,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>
@@ -24562,7 +24971,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');
@@ -24575,7 +24992,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' : '';
         
@@ -24726,6 +25147,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)) ||
@@ -24739,12 +25208,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];
@@ -24912,6 +25410,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));
@@ -24952,6 +25454,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';
@@ -24987,6 +25498,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) {
@@ -25055,8 +25573,13 @@ function renderInterviewPage(interviewId, resumeSlug) {
         render(data);
       }
 
+      function scrollToTop() {
+        window.scrollTo({ top: 0, left: 0, behavior: 'smooth' });
+      }
+
       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,
@@ -25064,10 +25587,14 @@ function renderInterviewPage(interviewId, resumeSlug) {
           };
         });
 
+        state.isSubmitting = true;
+        updateSubmitButton();
+
         const overlay = document.getElementById('loadingOverlay');
         const overlayText = document.getElementById('loadingText');
         overlay.classList.add('active');
         overlayText.textContent = "Submitting Answers...";
+        scrollToTop();
 
         try {
           const response = await fetch('/api/interviews/' + encodeURIComponent(interviewId) + '/answers', {
@@ -25080,6 +25607,8 @@ function renderInterviewPage(interviewId, resumeSlug) {
         } catch (err) {
           document.getElementById('submitStatus').textContent = 'Error submitting answers.';
         }
+        state.isSubmitting = false;
+        updateSubmitButton();
         try {
           await refresh();
         } catch (_error) {
@@ -26399,6 +26928,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;
@@ -26654,10 +27184,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;
@@ -26707,12 +27239,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;
@@ -26809,10 +27352,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;
@@ -27786,6 +28331,8 @@ class MultiplexerSessionManager {
   directory;
   multiplexer = null;
   sessions = new Map;
+  knownSessions = new Map;
+  spawningSessions = new Set;
   pollInterval;
   enabled = false;
   constructor(ctx, config) {
@@ -27814,45 +28361,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) {
@@ -27865,6 +28426,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) {
@@ -27879,6 +28444,7 @@ class MultiplexerSessionManager {
       sessionId
     });
     await this.closeSession(sessionId);
+    this.knownSessions.delete(sessionId);
   }
   startPolling() {
     if (this.pollInterval)
@@ -27939,6 +28505,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) {
@@ -27953,6 +28574,8 @@ class MultiplexerSessionManager {
       await Promise.all(closePromises);
       this.sessions.clear();
     }
+    this.knownSessions.clear();
+    this.spawningSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -28571,14 +29194,158 @@ Returns the councillor responses with a summary footer.`,
 *Council: ${completed}/${total} councillors responded (${composition})*`;
       const deprecated = councilManager.getDeprecatedFields();
       if (deprecated && deprecated.length > 0) {
+        const legacyMasterModel = councilManager.getLegacyMasterModel();
+        const hasMaster = deprecated.includes("master");
+        const trulyIgnored = hasMaster && !legacyMasterModel ? deprecated : deprecated.filter((f) => f !== "master");
+        const parts = [];
+        if (hasMaster && legacyMasterModel) {
+          parts.push(`\`council.master\` is deprecated and will be removed in a future version. Its \`model\` is currently used as a fallback for the council agent — add a \`council\` entry to your preset to make this explicit.`);
+        }
+        if (trulyIgnored.length > 0) {
+          parts.push(`${trulyIgnored.map((f) => `\`council.${f}\``).join(", ")} ${trulyIgnored.length === 1 ? "is" : "are"} deprecated and ignored — remove ${trulyIgnored.length === 1 ? "it" : "them"} from your config.`);
+        }
         output += `
-⚠ Config warning: ${deprecated.map((f) => `\`council.${f}\``).join(", ")} ${deprecated.length === 1 ? "is" : "are"} deprecated and ignored. The council agent synthesizes directly — remove ${deprecated.length === 1 ? "it" : "them"} from your config.`;
+⚠ Config warning: ${parts.join(" ")}`;
       }
       return output;
     }
   });
   return { council_session };
 }
+// src/tools/preset-manager.ts
+var COMMAND_NAME3 = "preset";
+function createPresetManager(ctx, config) {
+  let activePreset = config.preset ?? null;
+  async function handleCommandExecuteBefore(input, output) {
+    if (input.command !== COMMAND_NAME3) {
+      return;
+    }
+    output.parts.length = 0;
+    const arg = input.arguments.trim();
+    const presets = config.presets ?? {};
+    if (!arg) {
+      output.parts.push(createInternalAgentTextPart(formatPresetList(presets)));
+      return;
+    }
+    if (/\s/.test(arg)) {
+      const suggestion = arg.split(/\s+/)[0];
+      output.parts.push(createInternalAgentTextPart(`Preset names cannot contain spaces. Did you mean: /preset ${suggestion}?`));
+      return;
+    }
+    await switchPreset(arg, presets, output);
+  }
+  function registerCommand(opencodeConfig) {
+    const configCommand = opencodeConfig.command;
+    if (!configCommand?.[COMMAND_NAME3]) {
+      if (!opencodeConfig.command) {
+        opencodeConfig.command = {};
+      }
+      opencodeConfig.command[COMMAND_NAME3] = {
+        template: "List available presets and switch between them",
+        description: "Switch agent presets at runtime (e.g., /preset cheap, /preset powerful)"
+      };
+    }
+  }
+  async function switchPreset(presetName, presets, output) {
+    const preset = presets[presetName];
+    if (!preset) {
+      const available = Object.keys(presets);
+      const hint = available.length > 0 ? `Available presets: ${available.join(", ")}` : "No presets configured. Define presets in oh-my-opencode-slim.jsonc.";
+      output.parts.push(createInternalAgentTextPart(`Preset "${presetName}" not found. ${hint}`));
+      return;
+    }
+    const agentUpdates = {};
+    for (const [agentName, override] of Object.entries(preset)) {
+      const agentConfig = mapOverrideToAgentConfig(override);
+      if (Object.keys(agentConfig).length > 0) {
+        agentUpdates[agentName] = agentConfig;
+      }
+    }
+    if (Object.keys(agentUpdates).length === 0) {
+      output.parts.push(createInternalAgentTextPart(`Preset "${presetName}" is empty (no agent overrides defined).`));
+      return;
+    }
+    try {
+      await ctx.client.config.update({
+        body: { agent: agentUpdates }
+      });
+      activePreset = presetName;
+      const summary = Object.entries(agentUpdates).map(([name, cfg]) => {
+        const parts = [name];
+        if (cfg.model)
+          parts.push(`model: ${cfg.model}`);
+        if (cfg.variant)
+          parts.push(`variant: ${cfg.variant}`);
+        if (cfg.temperature !== undefined)
+          parts.push(`temp: ${cfg.temperature}`);
+        if (cfg.options)
+          parts.push("options: yes");
+        return parts.join(" → ");
+      }).join(`
+`);
+      output.parts.push(createInternalAgentTextPart(`Switched to preset "${presetName}":
+${summary}`));
+    } catch (err) {
+      output.parts.push(createInternalAgentTextPart(`Failed to switch preset "${presetName}": ${String(err)}`));
+    }
+  }
+  function mapOverrideToAgentConfig(override) {
+    const agentConfig = {};
+    if (typeof override.model === "string") {
+      agentConfig.model = override.model;
+    } else if (Array.isArray(override.model) && override.model.length > 0) {
+      const first = override.model[0];
+      agentConfig.model = typeof first === "string" ? first : first.id;
+      if (typeof first !== "string" && first.variant) {
+        agentConfig.variant = first.variant;
+      }
+    }
+    if (typeof override.temperature === "number") {
+      agentConfig.temperature = override.temperature;
+    }
+    if (typeof override.variant === "string") {
+      agentConfig.variant = override.variant;
+    }
+    if (override.options && typeof override.options === "object" && !Array.isArray(override.options)) {
+      agentConfig.options = override.options;
+    }
+    return agentConfig;
+  }
+  function formatPresetList(presets) {
+    const names = Object.keys(presets);
+    if (names.length === 0) {
+      return 'No presets configured. Define presets in oh-my-opencode-slim.jsonc under the "presets" field.';
+    }
+    const lines = ["Available presets:"];
+    for (const name of names) {
+      const marker = name === activePreset ? " ← active" : "";
+      const preset = presets[name];
+      const agentNames = Object.keys(preset);
+      const models = agentNames.map((a) => {
+        const cfg = preset[a];
+        const modelStr = typeof cfg.model === "string" ? cfg.model : Array.isArray(cfg.model) && cfg.model.length > 0 ? resolveFirstModel(cfg.model) : undefined;
+        return modelStr ? `    ${a} → ${modelStr}` : `    ${a}`;
+      }).join(`
+`);
+      lines.push(`  ${name}${marker}`);
+      lines.push(models);
+    }
+    lines.push(`
+Usage: /preset <name> to switch.`);
+    return lines.join(`
+`);
+  }
+  function resolveFirstModel(models) {
+    if (models.length === 0)
+      return;
+    const first = models[0];
+    return typeof first === "string" ? first : first.id;
+  }
+  return {
+    handleCommandExecuteBefore,
+    registerCommand
+  };
+}
 // src/tools/smartfetch/constants.ts
 var DOCS_HOST_SUFFIXES = [
   ".readthedocs.io",
@@ -30916,6 +31683,17 @@ class SubagentDepthTracker {
   }
 }
 
+// src/utils/system-collapse.ts
+function collapseSystemInPlace(system2) {
+  const joined = system2.join(`
+
+`);
+  system2.length = 0;
+  if (joined) {
+    system2.push(joined);
+  }
+}
+
 // src/index.ts
 async function appLog(ctx, level, message) {
   try {
@@ -30965,7 +31743,9 @@ var OhMyOpenCodeLite = async (ctx) => {
   let jsonErrorRecoveryHook;
   let foregroundFallback;
   let todoContinuationHook;
+  let taskSessionManagerHook;
   let interviewManager;
+  let presetManager;
   let councilTools;
   let webfetch;
   let toolCount = 0;
@@ -31023,7 +31803,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);
@@ -31042,7 +31822,12 @@ var OhMyOpenCodeLite = async (ctx) => {
       autoEnable: config.todoContinuation?.autoEnable ?? false,
       autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4
     });
+    taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
+      maxSessionsPerAgent: config.sessionManager?.maxSessionsPerAgent ?? 2,
+      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;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
@@ -31197,6 +31982,7 @@ var OhMyOpenCodeLite = async (ctx) => {
         };
       }
       interviewManager.registerCommand(opencodeConfig);
+      presetManager.registerCommand(opencodeConfig);
     },
     event: async (input) => {
       const event = input.event;
@@ -31215,6 +32001,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;
@@ -31228,10 +32015,12 @@ 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);
       await interviewManager.handleCommandExecuteBefore(input, output);
+      await presetManager.handleCommandExecuteBefore(input, output);
     },
     "chat.headers": chatHeadersHook["chat.headers"],
     "chat.message": async (input, output) => {
@@ -31262,10 +32051,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;
@@ -31297,6 +32084,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);
     }
   };
 };