oh-my-opencode-slim 1.0.1 → 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;
@@ -18525,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)"),
@@ -18566,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(),
@@ -18575,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()
@@ -18660,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)
     };
@@ -18931,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
@@ -18938,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
@@ -22057,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";
@@ -22372,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,
@@ -22450,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;
@@ -22880,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";
 
@@ -23764,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;");
 }
@@ -23861,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) => {
@@ -24075,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>
@@ -24276,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); 
@@ -24555,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>
@@ -24596,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');
@@ -24609,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' : '';
         
@@ -24760,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)) ||
@@ -24773,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];
@@ -24946,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));
@@ -24986,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';
@@ -25021,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) {
@@ -25094,7 +25578,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 +25587,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 +25607,8 @@ function renderInterviewPage(interviewId, resumeSlug) {
         } catch (err) {
           document.getElementById('submitStatus').textContent = 'Error submitting answers.';
         }
+        state.isSubmitting = false;
+        updateSubmitButton();
         try {
           await refresh();
         } catch (_error) {
@@ -26438,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;
@@ -26693,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;
@@ -26746,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;
@@ -26848,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;
@@ -27825,6 +28331,8 @@ class MultiplexerSessionManager {
   directory;
   multiplexer = null;
   sessions = new Map;
+  knownSessions = new Map;
+  spawningSessions = new Set;
   pollInterval;
   enabled = false;
   constructor(ctx, config) {
@@ -27853,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) {
@@ -27904,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) {
@@ -27918,6 +28444,7 @@ class MultiplexerSessionManager {
       sessionId
     });
     await this.closeSession(sessionId);
+    this.knownSessions.delete(sessionId);
   }
   startPolling() {
     if (this.pollInterval)
@@ -27978,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) {
@@ -27992,6 +28574,8 @@ class MultiplexerSessionManager {
       await Promise.all(closePromises);
       this.sessions.clear();
     }
+    this.knownSessions.clear();
+    this.spawningSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -31099,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 {
@@ -31148,6 +31743,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let jsonErrorRecoveryHook;
   let foregroundFallback;
   let todoContinuationHook;
+  let taskSessionManagerHook;
   let interviewManager;
   let presetManager;
   let councilTools;
@@ -31207,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);
@@ -31226,6 +31822,10 @@ 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;
@@ -31401,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;
@@ -31414,6 +32015,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);
@@ -31449,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;
@@ -31484,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);
     }
   };
 };