oh-my-opencode-slim 2.0.3 → 2.0.5

package/dist/index.js

@@ -18420,7 +18420,8 @@ var PERMISSION_ONLY_SKILLS = [
     description: "Code review template for reviewer subagents in multi-step workflows"
   }
 ];
-function getSkillPermissionsForAgent(agentName, skillList) {
+function getSkillPermissionsForAgent(agentName, skillList, disabledSkillNames) {
+  const disabledSkills = new Set(disabledSkillNames ?? []);
   const permissions = {
     "*": agentName === "orchestrator" ? "allow" : "deny"
   };
@@ -18431,24 +18432,30 @@ function getSkillPermissionsForAgent(agentName, skillList) {
         permissions["*"] = "allow";
       } else if (name.startsWith("!")) {
         permissions[name.slice(1)] = "deny";
-      } else {
+      } else if (!disabledSkills.has(name)) {
         permissions[name] = "allow";
       }
     }
+    for (const name of disabledSkills) {
+      permissions[name] = "deny";
+    }
     return permissions;
   }
   for (const skill of CUSTOM_SKILLS) {
     const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
+    if (isAllowed && !disabledSkills.has(skill.name)) {
       permissions[skill.name] = "allow";
     }
   }
   for (const skill of PERMISSION_ONLY_SKILLS) {
     const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
-    if (isAllowed) {
+    if (isAllowed && !disabledSkills.has(skill.name)) {
       permissions[skill.name] = "allow";
     }
   }
+  for (const name of disabledSkills) {
+    permissions[name] = "deny";
+  }
   return permissions;
 }
 
@@ -18471,14 +18478,14 @@ var ALL_AGENT_NAMES = ["orchestrator", ...SUBAGENT_NAMES];
 var PROTECTED_AGENTS = new Set(["orchestrator", "councillor"]);
 var DEFAULT_MODELS = {
   orchestrator: undefined,
-  oracle: "openai/gpt-5.5",
-  librarian: "openai/gpt-5.4-mini",
-  explorer: "openai/gpt-5.4-mini",
-  designer: "openai/gpt-5.4-mini",
-  fixer: "openai/gpt-5.4-mini",
-  observer: "openai/gpt-5.4-mini",
-  council: "openai/gpt-5.4-mini",
-  councillor: "openai/gpt-5.4-mini"
+  oracle: undefined,
+  librarian: undefined,
+  explorer: undefined,
+  designer: undefined,
+  fixer: undefined,
+  observer: undefined,
+  council: undefined,
+  councillor: undefined
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
@@ -18719,6 +18726,7 @@ var CompanionConfigSchema = z2.object({
   debug: z2.boolean().optional().describe("Enable verbose native companion debug logs.")
 });
 var AcpAgentPermissionModeSchema = z2.enum(["ask", "allow", "reject"]);
+var MAX_ACP_TIMEOUT_MS = 2147483647;
 var AcpAgentConfigSchema = z2.object({
   command: z2.string().min(1),
   args: z2.array(z2.string()).default([]),
@@ -18728,7 +18736,7 @@ var AcpAgentConfigSchema = z2.object({
   prompt: z2.string().min(1).optional(),
   orchestratorPrompt: z2.string().min(1).optional(),
   wrapperModel: ProviderModelIdSchema.optional(),
-  timeoutMs: z2.number().int().min(1000).max(900000).default(300000),
+  timeoutMs: z2.number().int().min(0).max(MAX_ACP_TIMEOUT_MS).default(0).describe("Timeout for a single ACP run in milliseconds. Set to 0 to disable the timeout."),
   permissionMode: AcpAgentPermissionModeSchema.default("ask")
 }).strict();
 var AcpAgentsConfigSchema = z2.record(z2.string(), AcpAgentConfigSchema);
@@ -18762,6 +18770,8 @@ var PluginConfigSchema = z2.object({
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
   disabled_agents: z2.array(z2.string()).optional().describe("Agent names to disable completely. " + "Disabled agents are not instantiated and cannot be delegated to. " + "Orchestrator and council internal agents (councillor) cannot be disabled. " + "By default, 'observer' is disabled. Remove it from this list and configure a vision-capable model to enable."),
   disabled_mcps: z2.array(z2.string()).optional(),
+  disabled_tools: z2.array(z2.string()).optional().describe("Tool names to disable completely. Disabled tools are not registered with OpenCode and cannot be used by agents."),
+  disabled_skills: z2.array(z2.string()).optional().describe("Skill names to disable completely. Disabled skills are not granted to agents, even when referenced by presets or agent overrides."),
   multiplexer: MultiplexerConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
@@ -19251,6 +19261,11 @@ Build a short work graph before dispatching:
 - Advisory ownership for write-capable lanes
 - Verification/review lanes that run after implementation
 
+### Todo Continuity
+- When the user adds a new task while a todo list exists, append the new task to the end of the existing todo list instead of replacing the list.
+- Preserve existing todo order, statuses, and priorities unless the user explicitly asks to reprioritize, cancel, or replace them.
+- Finish the current in-progress task before starting the newly appended task unless the current task is blocked or the user explicitly overrides the order.
+
 Can tasks be split into background specialist work?
 ${enabledParallelExamples}
 
@@ -19258,6 +19273,7 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 
 ### Background Task Discipline
 - Prefer \`task(..., background: true)\` for delegated work that can run independently.
+- Launch specialist agents in the background by default so the orchestrator stays unblocked and can reconcile results when they return.
 - Track each task's specialist, objective, task/session ID, and file/topic ownership.
 - Continue orchestration only on non-overlapping work; otherwise briefly report what was launched and stop.
 - Before local edits or another writer task, compare against running task scopes.
@@ -19346,10 +19362,31 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt, disabl
   return definition;
 }
 
+// src/agents/permissions.ts
+function createReadOnlyAgentPermission() {
+  return {
+    "*": "deny",
+    bash: "deny",
+    edit: "deny",
+    write: "deny",
+    apply_patch: "deny",
+    ast_grep_replace: "deny",
+    task: "deny",
+    question: "deny",
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    lsp: "allow",
+    list: "allow",
+    codesearch: "allow",
+    ast_grep_search: "allow"
+  };
+}
+
 // src/agents/council.ts
 var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestration system that runs consensus across multiple models.
 
-**Tool**: You have access to the \`council_session\` tool.
+**Tool**: You have access to the \`council_session\` tool. You also have read-only codebase inspection tools. You do not have write, edit, shell, or subagent-delegation tools.
 
 **When to use**:
 - When invoked by a user with a request
@@ -19410,7 +19447,11 @@ function createCouncilAgent(model, customPrompt, customAppendPrompt) {
     description: "Multi-LLM council agent that synthesizes responses from multiple models for higher-quality outputs",
     config: {
       temperature: 0.1,
-      prompt
+      prompt,
+      permission: {
+        ...createReadOnlyAgentPermission(),
+        council_session: "allow"
+      }
     }
   };
   if (model) {
@@ -19519,17 +19560,7 @@ function createCouncillorAgent(model, customPrompt, customAppendPrompt) {
       model,
       temperature: 0.2,
       prompt,
-      permission: {
-        "*": "deny",
-        question: "deny",
-        read: "allow",
-        glob: "allow",
-        grep: "allow",
-        lsp: "allow",
-        list: "allow",
-        codesearch: "allow",
-        ast_grep_search: "allow"
-      }
+      permission: createReadOnlyAgentPermission()
     }
   };
 }
@@ -19869,7 +19900,38 @@ function normalizeDisplayName(displayName) {
   const trimmed = displayName.trim();
   return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
 }
-function buildAcpAgentDefinition(name, config) {
+function getPrimaryModelFromOverride(override) {
+  const model = override?.model;
+  if (typeof model === "string") {
+    return model;
+  }
+  if (Array.isArray(model) && model.length > 0) {
+    const first = model[0];
+    return typeof first === "string" ? first : first?.id;
+  }
+  return;
+}
+function getActivePresetPrimaryModel(config) {
+  const activePreset = config?.preset ? config.presets?.[config.preset] : undefined;
+  if (!activePreset) {
+    return;
+  }
+  const orchestratorModel = getPrimaryModelFromOverride(activePreset.orchestrator);
+  if (orchestratorModel) {
+    return orchestratorModel;
+  }
+  for (const name of SUBAGENT_NAMES) {
+    const model = getPrimaryModelFromOverride(activePreset[name]);
+    if (model) {
+      return model;
+    }
+  }
+  return;
+}
+function getConfigPrimaryModel(config) {
+  return getActivePresetPrimaryModel(config);
+}
+function buildAcpAgentDefinition(name, config, fallbackModel) {
   const description = config.description ?? `External ACP agent '${name}' via ${config.command}`;
   const prompt = config.prompt ?? [
     `You are the ${name} ACP wrapper agent.`,
@@ -19883,7 +19945,7 @@ function buildAcpAgentDefinition(name, config) {
     name,
     description,
     config: {
-      model: config.wrapperModel ?? DEFAULT_MODELS.fixer ?? DEFAULT_MODELS.librarian ?? DEFAULT_MODELS.orchestrator ?? DEFAULT_MODELS.oracle,
+      model: config.wrapperModel ?? fallbackModel ?? DEFAULT_MODELS.oracle,
       temperature: 0,
       prompt,
       permission: {
@@ -19948,10 +20010,11 @@ function hasCustomAgentModel(override) {
 }
 function buildCustomAgentDefinition(name, override, filePrompt, fileAppendPrompt) {
   const basePrompt = override.prompt ?? `You are the ${name} specialist.`;
+  const primaryModel = getPrimaryModelFromOverride(override);
   return {
     name,
     config: {
-      model: typeof override.model === "string" ? override.model : DEFAULT_MODELS.orchestrator ?? DEFAULT_MODELS.oracle,
+      model: primaryModel ?? DEFAULT_MODELS.oracle,
       temperature: 0.2,
       prompt: resolvePrompt(basePrompt, filePrompt, fileAppendPrompt)
     }
@@ -19968,9 +20031,9 @@ function injectDisplayNames(orchestrator, nameMap) {
   }
   orchestrator.config.prompt = prompt;
 }
-function applyDefaultPermissions(agent, configuredSkills) {
+function applyDefaultPermissions(agent, configuredSkills, disabledSkills) {
   const existing = agent.config.permission ?? {};
-  const skillPermissions = getSkillPermissionsForAgent(agent.name, configuredSkills);
+  const skillPermissions = getSkillPermissionsForAgent(agent.name, configuredSkills, disabledSkills);
   const questionPerm = existing.question === "deny" ? "deny" : "allow";
   const councilSessionPerm = COUNCIL_TOOL_ALLOWED_AGENTS.has(agent.name) ? existing.council_session ?? "allow" : "deny";
   const cancelTaskPerm = CANCEL_TASK_ALLOWED_AGENTS.has(agent.name) ? existing.cancel_task ?? "allow" : "deny";
@@ -20003,6 +20066,7 @@ function createAgents(config) {
   if (!config?.council) {
     disabled.add("council");
   }
+  const primaryModel = getConfigPrimaryModel(config);
   const getModelForAgent = (name) => {
     if (name === "fixer" && !getAgentOverride(config, "fixer")?.model) {
       const librarianOverride = getAgentOverride(config, "librarian")?.model;
@@ -20013,9 +20077,9 @@ function createAgents(config) {
       } else {
         librarianModel = librarianOverride;
       }
-      return librarianModel ?? DEFAULT_MODELS.librarian;
+      return librarianModel ?? primaryModel ?? DEFAULT_MODELS.librarian;
     }
-    return DEFAULT_MODELS[name];
+    return primaryModel ?? DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).filter(([name]) => !disabled.has(name)).map(([name, factory]) => {
     const customPrompts = loadAgentPrompt(name, config?.preset);
@@ -20057,14 +20121,14 @@ function createAgents(config) {
     const acp = config?.acpAgents?.[name];
     if (!acp)
       throw new Error(`ACP agent '${name}' is missing config`);
-    return buildAcpAgentDefinition(name, acp);
+    return buildAcpAgentDefinition(name, acp, primaryModel);
   });
   const builtInSubAgents = protoSubAgents.map((agent) => {
     const override = getAgentOverride(config, agent.name);
     if (override) {
       applyOverrides(agent, override);
     }
-    applyDefaultPermissions(agent, override?.skills);
+    applyDefaultPermissions(agent, override?.skills, config?.disabled_skills);
     return agent;
   });
   const legacyMasterModel = config?.council?._legacyMasterModel;
@@ -20079,11 +20143,11 @@ function createAgents(config) {
     if (override) {
       applyOverrides(agent, override);
     }
-    applyDefaultPermissions(agent, override?.skills);
+    applyDefaultPermissions(agent, override?.skills, config?.disabled_skills);
     return agent;
   });
   const acpSubAgents = protoAcpAgents.map((agent) => {
-    applyDefaultPermissions(agent);
+    applyDefaultPermissions(agent, undefined, config?.disabled_skills);
     return agent;
   });
   const allSubAgents = [
@@ -20095,7 +20159,7 @@ function createAgents(config) {
   const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
   const orchestratorPrompts = loadAgentPrompt("orchestrator", config?.preset);
   const orchestrator = createOrchestratorAgent(orchestratorModel, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt, disabled);
-  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills);
+  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills, config?.disabled_skills);
   if (orchestratorOverride) {
     applyOverrides(orchestrator, orchestratorOverride);
   }
@@ -20374,6 +20438,7 @@ class CompanionManager {
   status = "idle";
   busyAgentSessions = new Map;
   config;
+  companionProcess = null;
   constructor(sessionId, cwd, config) {
     this.id = sessionId;
     this.cwd = cwd;
@@ -20438,6 +20503,12 @@ class CompanionManager {
   onExit() {
     if (this.config?.enabled !== true)
       return;
+    if (this.companionProcess) {
+      try {
+        this.companionProcess.kill();
+      } catch {}
+      this.companionProcess = null;
+    }
     writeState((state) => {
       state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
     });
@@ -20514,6 +20585,7 @@ class CompanionManager {
         },
         stdio: "ignore"
       });
+      this.companionProcess = child;
       child.unref();
       log("[companion] spawned", JSON.stringify({
         bin,
@@ -21010,7 +21082,15 @@ class CouncilManager {
       const body = {
         agent: options.agent,
         model: modelRef,
-        tools: { task: false },
+        tools: {
+          task: false,
+          question: false,
+          edit: false,
+          write: false,
+          apply_patch: false,
+          ast_grep_replace: false,
+          bash: false
+        },
         parts: [{ type: "text", text: options.promptText }]
       };
       if (options.variant) {
@@ -23537,6 +23617,7 @@ var AGENT_PREFIX = {
 class BackgroundJobBoard {
   jobs = new Map;
   counters = new Map;
+  terminalStateListener;
   maxReusablePerAgent;
   readContextMinLines;
   readContextMaxFiles;
@@ -23545,6 +23626,9 @@ class BackgroundJobBoard {
     this.readContextMinLines = options.readContextMinLines ?? 10;
     this.readContextMaxFiles = options.readContextMaxFiles ?? 8;
   }
+  setTerminalStateListener(listener) {
+    this.terminalStateListener = listener;
+  }
   registerLaunch(input) {
     const now = input.now ?? Date.now();
     const existing = this.jobs.get(input.taskID);
@@ -23602,6 +23686,7 @@ class BackgroundJobBoard {
     }
     const now = input.now ?? Date.now();
     const terminal = TERMINAL_STATES.has(input.state);
+    const notifyTerminal = terminal && !TERMINAL_STATES.has(existing.state);
     const updated = {
       ...existing,
       state: input.state,
@@ -23616,6 +23701,8 @@ class BackgroundJobBoard {
     };
     this.jobs.set(input.taskID, updated);
     this.trimReusable(input.taskID);
+    if (notifyTerminal)
+      this.terminalStateListener?.(input.taskID);
     return updated;
   }
   updateFromStatusOutput(output) {
@@ -23680,6 +23767,7 @@ class BackgroundJobBoard {
       if (TERMINAL_STATES.has(existing.state))
         return existing;
     }
+    const notifyTerminal = !TERMINAL_STATES.has(existing.state) && existing.state !== "reconciled";
     const summary = normalizeCancelReason(reason);
     const updated = {
       ...existing,
@@ -23695,6 +23783,8 @@ class BackgroundJobBoard {
       lastStatusError: undefined
     };
     this.jobs.set(taskID, updated);
+    if (notifyTerminal)
+      this.terminalStateListener?.(taskID);
     return updated;
   }
   get(taskID) {
@@ -24147,7 +24237,7 @@ function createFilterAvailableSkillsHook(_ctx, config) {
       return cached;
     }
     const configuredSkills = getAgentOverride(config, agentName)?.skills;
-    const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+    const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills, config.disabled_skills);
     permissionRulesByAgent.set(agentName, permissionRules);
     return permissionRules;
   };
@@ -24747,17 +24837,6 @@ function createReflectCommandHook() {
 }
 // src/hooks/task-session-manager/index.ts
 import path12 from "node:path";
-var AGENT_NAME_SET = new Set([
-  "orchestrator",
-  "oracle",
-  "designer",
-  "explorer",
-  "librarian",
-  "fixer",
-  "observer",
-  "council",
-  "councillor"
-]);
 var MAX_PENDING_TASK_CALLS = 100;
 var BACKGROUND_JOB_BOARD_SENTINEL = "SENTINEL: background-job-board-v2";
 var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
@@ -24789,9 +24868,6 @@ function createOccurrenceId(part, message, partIndex) {
   const hash = djb2Hash(`${sessionID}:${content}`);
   return `anon:${hash}`;
 }
-function isAgentName(value) {
-  return typeof value === "string" && AGENT_NAME_SET.has(value);
-}
 function extractPath(output) {
   return /<path>([^<]+)<\/path>/.exec(output)?.[1];
 }
@@ -25072,16 +25148,17 @@ function createTaskSessionManagerHook(_ctx, options) {
       if (!isRecord(output.args))
         return;
       const args = output.args;
-      if (!isAgentName(args.subagent_type)) {
+      if (typeof args.subagent_type !== "string" || args.subagent_type.trim() === "") {
         if (typeof args.task_id === "string" && args.task_id.trim() !== "") {
           delete args.task_id;
         }
         return;
       }
+      const agentType = args.subagent_type.trim();
       const label = deriveTaskSessionLabel({
         description: typeof args.description === "string" ? args.description : undefined,
         prompt: typeof args.prompt === "string" ? args.prompt : undefined,
-        agentType: args.subagent_type
+        agentType
       });
       const pendingCall = {
         callId: pendingCallId({
@@ -25089,7 +25166,7 @@ function createTaskSessionManagerHook(_ctx, options) {
           sessionID: input.sessionID
         }),
         parentSessionId: input.sessionID,
-        agentType: args.subagent_type,
+        agentType,
         label
       };
       rememberPendingCall(pendingCall);
@@ -25097,7 +25174,7 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       }
       const requested = args.task_id.trim();
-      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, args.subagent_type);
+      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, agentType);
       if (!remembered) {
         if (RAW_SESSION_ID_PATTERN.test(requested)) {
           pendingCall.resumedTaskId = requested;
@@ -25434,26 +25511,25 @@ function slugify(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
 }
 function extractHistorySection(document) {
-  const marker = `## Q&A history
-
-`;
-  const index = document.indexOf(marker);
-  return index >= 0 ? document.slice(index + marker.length).trim() : "";
+  const marker = /## Q&A history/i;
+  const match = document.match(marker);
+  if (!match || match.index === undefined)
+    return "";
+  return document.slice(match.index + match[0].length).trim();
 }
 function extractSummarySection(document) {
   const marker = `## Current spec
 
 `;
-  const historyMarker = `
-
-## Q&A history`;
   const start = document.indexOf(marker);
   if (start < 0) {
     return "";
   }
   const summaryStart = start + marker.length;
-  const summaryEnd = document.indexOf(historyMarker, summaryStart);
-  return document.slice(summaryStart, summaryEnd >= 0 ? summaryEnd : undefined).trim();
+  const historyMarker = /\n\n## Q&A history/i;
+  const historyMatch = document.slice(summaryStart).match(historyMarker);
+  const summaryEnd = historyMatch?.index !== undefined ? summaryStart + historyMatch.index : undefined;
+  return document.slice(summaryStart, summaryEnd).trim();
 }
 function extractTitle(document) {
   const match = document.match(/^#\s+(.+)$/m);
@@ -25462,11 +25538,19 @@ function extractTitle(document) {
 function buildInterviewDocument(idea, summary, history, meta) {
   const normalizedSummary = summary.trim() || "Waiting for interview answers.";
   const normalizedHistory = history.trim() || "No answers yet.";
+  const now = new Date;
+  const dateStr = now.toISOString().split("T")[0];
+  const owner = meta?.owner ?? "agent";
+  const tags = meta?.tags ?? ["spec", "diagnostic"];
   const frontmatter = meta?.sessionID ? [
     "---",
     `sessionID: ${meta.sessionID}`,
     `baseMessageCount: ${meta.baseMessageCount ?? 0}`,
-    `updatedAt: ${new Date().toISOString()}`,
+    `updatedAt: ${now.toISOString()}`,
+    `version: 1.0`,
+    `date_created: ${dateStr}`,
+    `owner: ${owner}`,
+    `tags: [${tags.join(", ")}]`,
     "---",
     ""
   ].join(`
@@ -25548,6 +25632,55 @@ A: ${answer.answer.trim()}` : null;
     baseMessageCount: record.baseMessageCount
   }), "utf8");
 }
+function parseSpecBlocks(markdown) {
+  const blocks = [];
+  const lines = markdown.split(`
+`);
+  let currentBlockId = null;
+  let currentBlockTitle = null;
+  let currentBlockLines = [];
+  const flush = () => {
+    if (currentBlockId) {
+      blocks.push({
+        id: currentBlockId,
+        title: currentBlockTitle || currentBlockId,
+        content: currentBlockLines.join(`
+`).trim()
+      });
+    }
+  };
+  for (const line of lines) {
+    if (/^##\s+Q&A history\s*$/i.test(line)) {
+      break;
+    }
+    const headerMatch = line.match(/^##\s+(\d+)\.\s+(.+)$/);
+    if (headerMatch) {
+      flush();
+      const num = headerMatch[1];
+      const name = headerMatch[2].trim();
+      currentBlockId = `section-${num}`;
+      currentBlockTitle = `${num}. ${name}`;
+      currentBlockLines = [];
+    } else if (line.startsWith("# ") && !line.startsWith("## ")) {
+      if (currentBlockId === null) {
+        currentBlockId = "section-0";
+        currentBlockTitle = "Introduction";
+        currentBlockLines = [];
+      }
+    } else if (line.startsWith("## ") && !headerMatch) {
+      flush();
+      const name = line.replace(/^##\s+/, "").trim();
+      currentBlockId = `section-${slugify(name)}`;
+      currentBlockTitle = name;
+      currentBlockLines = [];
+    }
+    if (currentBlockId !== null) {
+      currentBlockLines.push(line);
+    }
+  }
+  flush();
+  return blocks;
+}
 
 // src/interview/helpers.ts
 function sendJson(response, status, value) {
@@ -26037,6 +26170,65 @@ function renderInterviewPage(interviewId, resumeSlug) {
     <style>
       ${sharedStyles()}
       .brand-mark { width: 144px; height: 144px; }
+      .spec-block-card {
+        background: rgba(255,255,255,0.01);
+        border: 1px solid rgba(255,255,255,0.05);
+        border-radius: 8px;
+        padding: 24px;
+        margin-bottom: 20px;
+        text-align: left;
+        transition: all 0.2s ease;
+      }
+      .spec-block-card:hover {
+        border-color: rgba(255,255,255,0.15);
+        background: rgba(255,255,255,0.02);
+      }
+      .spec-block-card h3 {
+        margin-top: 0;
+        font-size: 18px;
+        color: #ffffff;
+        border-bottom: 1px solid rgba(255,255,255,0.08);
+        padding-bottom: 8px;
+        margin-bottom: 14px;
+      }
+      .spec-block-content {
+        font-size: 15px;
+        line-height: 1.6;
+        color: rgba(255,255,255,0.8);
+      }
+      .spec-block-comment-box {
+        margin-top: 16px;
+        padding-top: 16px;
+        border-top: 1px dashed rgba(255,255,255,0.08);
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+      }
+      .spec-block-comment-input {
+        min-height: 60px !important;
+        font-size: 14px !important;
+        padding: 10px !important;
+      }
+      .comment-submit-btn {
+        align-self: flex-end;
+        background: transparent;
+        border: 1px solid rgba(255,255,255,0.2);
+        color: rgba(255,255,255,0.8);
+        padding: 8px 16px;
+        border-radius: 6px;
+        font-size: 13px;
+        cursor: pointer;
+        transition: all 0.2s ease;
+      }
+      .comment-submit-btn:hover:not(:disabled) {
+        border-color: #34d399;
+        color: #34d399;
+        background: rgba(52,211,153,0.05);
+      }
+      .comment-submit-btn:disabled {
+        opacity: 0.3;
+        cursor: not-allowed;
+      }
       h1 { font-size: 32px; font-weight: 600; letter-spacing: -0.02em; margin-bottom: 12px; line-height: 1.2; }
       h2 { font-size: 18px; font-weight: 500; letter-spacing: 0.05em; text-transform: uppercase; color: rgba(255,255,255,0.4); margin-bottom: 24px; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 12px; }
       h3 { font-size: 18px; font-weight: 500; margin-bottom: 16px; line-height: 1.4; }
@@ -26402,9 +26594,102 @@ function renderInterviewPage(interviewId, resumeSlug) {
         background: rgba(52,211,153,0.05);
       }
       .nudge-btn:disabled { opacity: 0.3; cursor: not-allowed; }
+
+      /* ── TOC Sidebar ──────────────────────────────────────────────── */
+      .toc-sidebar {
+        position: fixed;
+        top: 0; left: 0; bottom: 0;
+        width: 240px;
+        background: rgba(255,255,255,0.02);
+        border-right: 1px solid rgba(255,255,255,0.06);
+        padding: 24px 0 80px;
+        overflow-y: auto;
+        z-index: 50;
+        display: none;
+      }
+      .toc-sidebar.visible { display: block; }
+      .toc-header {
+        font-size: 11px;
+        font-weight: 700;
+        letter-spacing: 0.12em;
+        text-transform: uppercase;
+        color: rgba(255,255,255,0.28);
+        padding: 0 20px 14px;
+        border-bottom: 1px solid rgba(255,255,255,0.05);
+        margin-bottom: 8px;
+      }
+      .toc-item {
+        display: block;
+        padding: 7px 20px;
+        font-size: 13px;
+        color: rgba(255,255,255,0.5);
+        text-decoration: none;
+        cursor: pointer;
+        transition: all 0.15s ease;
+        border-left: 2px solid transparent;
+        line-height: 1.4;
+      }
+      .toc-item:hover {
+        color: rgba(255,255,255,0.85);
+        background: rgba(255,255,255,0.03);
+      }
+      .toc-item.active {
+        color: #ffffff;
+        border-left-color: #ffffff;
+        background: rgba(255,255,255,0.04);
+      }
+      body.toc-visible .wrap {
+        margin-left: 240px;
+      }
+
+      /* ── Chat Panel ───────────────────────────────────────────────── */
+      .chat-panel {
+        position: fixed;
+        bottom: 0; left: 0; right: 0;
+        background: rgba(0,0,0,0.92);
+        backdrop-filter: blur(12px);
+        border-top: 1px solid rgba(255,255,255,0.08);
+        padding: 12px 20px;
+        z-index: 60;
+        display: none;
+        gap: 10px;
+        align-items: center;
+      }
+      .chat-panel.visible { display: flex; }
+      body.chat-visible .wrap { padding-bottom: 72px; }
+      body.toc-visible .chat-panel { left: 240px; }
+      .chat-input {
+        flex: 1;
+        background: rgba(255,255,255,0.06);
+        border: 1px solid rgba(255,255,255,0.1);
+        border-radius: 8px;
+        color: #ffffff;
+        font-family: inherit;
+        font-size: 14px;
+        padding: 10px 14px;
+        outline: none;
+        transition: border-color 0.2s ease;
+      }
+      .chat-input:focus { border-color: rgba(255,255,255,0.35); }
+      .chat-input::placeholder { color: rgba(255,255,255,0.3); }
+      .chat-send {
+        flex-shrink: 0;
+        background: #ffffff;
+        color: #000000;
+        border: 0;
+        border-radius: 8px;
+        padding: 10px 18px;
+        font-size: 14px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: opacity 0.2s ease;
+      }
+      .chat-send:hover:not(:disabled) { opacity: 0.85; }
+      .chat-send:disabled { opacity: 0.3; cursor: not-allowed; }
     </style>
   </head>
   <body>
+    <nav id="tocSidebar" class="toc-sidebar"></nav>
     <div class="wrap">
       <a href="/" class="back-link">← All Interviews</a>
       <div class="brand-header">
@@ -26445,6 +26730,11 @@ function renderInterviewPage(interviewId, resumeSlug) {
       <div class="status-text" id="loadingText">Processing...</div>
     </div>
 
+    <div class="chat-panel" id="chatPanel">
+      <input type="text" id="chatInput" class="chat-input" placeholder="Send a message to the agent — add a section, revise content, ask questions..." autocomplete="off" />
+      <button class="chat-send" id="chatSendBtn" type="button" disabled>Send</button>
+    </div>
+
     <script>
       ${clipboardHelperJs()}
       const interviewId = ${JSON.stringify(interviewId).replace(/</g, "\\u003c")};
@@ -26814,21 +27104,94 @@ function renderInterviewPage(interviewId, resumeSlug) {
         return paragraphs.map(p => \`<p>\${p.replace(/\\n/g, '<br>')}</p>\`).join('');
       }
 
+      async function submitBlockComment(sectionTitle, commentText, button) {
+        if (!commentText.trim()) return;
+        button.disabled = true;
+        const submitStatus = document.getElementById('submitStatus');
+        submitStatus.textContent = '';
+        
+        try {
+          const res = await fetch('/api/interviews/' + encodeURIComponent(interviewId) + '/block-comment', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ section: sectionTitle, comment: commentText }),
+          });
+          const payload = await res.json();
+          if (res.ok) {
+            submitStatus.textContent = 'Feedback queued for block: ' + sectionTitle;
+            const input = button.previousElementSibling;
+            if (input) input.value = '';
+            refresh().catch(() => {});
+          } else {
+            submitStatus.textContent = payload.error || 'Failed to submit comment.';
+          }
+        } catch (err) {
+          submitStatus.textContent = 'Error submitting block connection feedback.';
+        } finally {
+          button.disabled = false;
+        }
+      }
+
       function renderCompletedView(data) {
         const container = document.getElementById('questions');
-        const { spec, qaPairs } = parseDocument(data.document);
         const frag = document.createDocumentFragment();
 
-        // Spec section
-        if (spec) {
+        const blocks = data.blocks || [];
+        if (blocks.length > 0) {
           const specLabel = document.createElement('div');
           specLabel.className = 'section-label';
-          specLabel.textContent = 'Current Spec';
+          specLabel.textContent = 'Interactive Specifications (11 Sections)';
           frag.appendChild(specLabel);
-          const specBlock = document.createElement('div');
-          specBlock.className = 'spec-block';
-          specBlock.innerHTML = simpleMarkdown(spec);
-          frag.appendChild(specBlock);
+
+          for (const block of blocks) {
+            const card = document.createElement('div');
+            card.className = 'spec-block-card';
+
+            const header = document.createElement('h3');
+            header.textContent = block.title;
+            card.appendChild(header);
+
+            const content = document.createElement('div');
+            content.className = 'spec-block-content';
+            content.innerHTML = simpleMarkdown(block.content);
+            card.appendChild(content);
+
+            // Per-block comment integration for micro annotations
+            const commentBox = document.createElement('div');
+            commentBox.className = 'spec-block-comment-box';
+
+            const textarea = document.createElement('textarea');
+            textarea.className = 'spec-block-comment-input';
+            textarea.placeholder = 'Provide review comment/revision for ' + block.title + '...';
+            commentBox.appendChild(textarea);
+
+            const sendBtn = document.createElement('button');
+            sendBtn.className = 'comment-submit-btn';
+            sendBtn.type = 'button';
+            sendBtn.textContent = 'Revise Section';
+            sendBtn.addEventListener('click', () => {
+              submitBlockComment(block.title, textarea.value, sendBtn);
+            });
+            commentBox.appendChild(sendBtn);
+
+            card.appendChild(commentBox);
+            frag.appendChild(card);
+          }
+        } else {
+          // Fallback legacy parse if blocks array isn't populated
+          const { spec, qaPairs } = parseDocument(data.document);
+
+          // Spec section
+          if (spec) {
+            const specLabel = document.createElement('div');
+            specLabel.className = 'section-label';
+            specLabel.textContent = 'Current Spec';
+            frag.appendChild(specLabel);
+            const specBlock = document.createElement('div');
+            specBlock.className = 'spec-block';
+            specBlock.innerHTML = simpleMarkdown(spec);
+            frag.appendChild(specBlock);
+          }
         }
 
         // Q&A section
@@ -26837,6 +27200,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
         qaLabel.textContent = 'Q&A History';
         frag.appendChild(qaLabel);
 
+        const { qaPairs } = parseDocument(data.document);
         if (!qaPairs.length) {
           const empty = document.createElement('p');
           empty.className = 'qa-empty';
@@ -26885,6 +27249,103 @@ function renderInterviewPage(interviewId, resumeSlug) {
         container.replaceChildren(frag);
       }
 
+      // ── TOC Sidebar ──────────────────────────────────────────────
+      function updateTocSidebar(data) {
+        const sidebar = document.getElementById('tocSidebar');
+        const blocks = data.blocks || [];
+        const isDone = ['completed', 'session-disconnected'].includes(data.mode);
+        if (!isDone || !blocks.length) {
+          sidebar.classList.remove('visible');
+          document.body.classList.remove('toc-visible');
+          return;
+        }
+        sidebar.classList.add('visible');
+        document.body.classList.add('toc-visible');
+        sidebar.innerHTML = '';
+        const header = document.createElement('div');
+        header.className = 'toc-header';
+        header.textContent = 'Sections';
+        sidebar.appendChild(header);
+        blocks.forEach((block) => {
+          const item = document.createElement('a');
+          item.className = 'toc-item';
+          item.textContent = block.title;
+          item.addEventListener('click', () => {
+            const cards = document.querySelectorAll('.spec-block-card h3');
+            for (const h3 of cards) {
+              if (h3.textContent === block.title) {
+                h3.closest('.spec-block-card').scrollIntoView({ behavior: 'smooth', block: 'start' });
+                break;
+              }
+            }
+            document.querySelectorAll('.toc-item').forEach((el) => el.classList.remove('active'));
+            item.classList.add('active');
+          });
+          sidebar.appendChild(item);
+        });
+      }
+
+      // ── Chat Panel ───────────────────────────────────────────────
+      function updateChatPanel(data) {
+        const panel = document.getElementById('chatPanel');
+        const input = document.getElementById('chatInput');
+        const sendBtn = document.getElementById('chatSendBtn');
+        const isDone = ['completed', 'session-disconnected'].includes(data.mode);
+        if (!isDone) {
+          panel.classList.remove('visible');
+          document.body.classList.remove('chat-visible');
+          return;
+        }
+        panel.classList.add('visible');
+        document.body.classList.add('chat-visible');
+        const busy = data.isBusy || false;
+        sendBtn.disabled = busy;
+        input.disabled = busy;
+        if (busy) {
+          input.placeholder = 'Agent is processing...';
+        } else {
+          input.placeholder = 'Send a message to the agent — add a section, revise content, ask questions...';
+        }
+      }
+
+      async function sendChatMessage() {
+        const input = document.getElementById('chatInput');
+        const sendBtn = document.getElementById('chatSendBtn');
+        const message = input.value.trim();
+        if (!message) return;
+        sendBtn.disabled = true;
+        input.value = '';
+        const submitStatus = document.getElementById('submitStatus');
+        submitStatus.textContent = '';
+        try {
+          const res = await fetch('/api/interviews/' + encodeURIComponent(interviewId) + '/chat', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ message }),
+          });
+          const payload = await res.json();
+          if (res.ok) {
+            submitStatus.textContent = 'Chat message sent to agent.';
+            refresh().catch(() => {});
+            schedulePoll();
+          } else {
+            submitStatus.textContent = payload.message || payload.error || 'Failed to send chat message.';
+            sendBtn.disabled = false;
+          }
+        } catch (_err) {
+          submitStatus.textContent = 'Network error sending chat message.';
+          sendBtn.disabled = false;
+        }
+      }
+
+      document.getElementById('chatSendBtn').addEventListener('click', sendChatMessage);
+      document.getElementById('chatInput').addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+          e.preventDefault();
+          sendChatMessage();
+        }
+      });
+
       function renderQuestions(questions) {
         const sig = JSON.stringify([questions, state.data?.mode]);
         const container = document.getElementById('questions');
@@ -27041,6 +27502,19 @@ function renderInterviewPage(interviewId, resumeSlug) {
         
         renderQuestions(data.questions || []);
         updateSubmitButton();
+        updateTocSidebar(data);
+        updateChatPanel(data);
+
+        // If we transitioned to a non-terminal state and connection/polling is stopped, restart them
+        const terminalModes = ['abandoned', 'completed', 'session-disconnected'];
+        if (!terminalModes.includes(data.mode)) {
+          if (!sseConnected && !activeEs) {
+            connectSse();
+          }
+          if (!sseConnected && !pollFallbackTimer) {
+            schedulePoll();
+          }
+        }
       }
 
       async function refresh() {
@@ -27151,19 +27625,65 @@ function renderInterviewPage(interviewId, resumeSlug) {
       document.getElementById('moreQuestionsBtn').addEventListener('click', () => sendNudge('more-questions'));
       document.getElementById('confirmCompleteBtn').addEventListener('click', () => sendNudge('confirm-complete'));
 
+      // ── Real-time updates via SSE ─────────────────────────────────
+      let sseConnected = false;
+      let pollFallbackTimer = null;
+      let activeEs = null;
+
+      function connectSse() {
+        if (activeEs) {
+          activeEs.close();
+        }
+        const sseUrl = '/api/interviews/' + encodeURIComponent(interviewId) + '/events';
+        const es = new EventSource(sseUrl);
+        activeEs = es;
+
+        es.addEventListener('state', (e) => {
+          sseConnected = true;
+          if (pollFallbackTimer) {
+            clearTimeout(pollFallbackTimer);
+            pollFallbackTimer = null;
+          }
+          try {
+            const data = JSON.parse(e.data);
+            render(data);
+          } catch (_) {}
+        });
+
+        es.onerror = () => {
+          sseConnected = false;
+          es.close();
+          activeEs = null;
+          const terminalModes = ['abandoned', 'completed', 'session-disconnected'];
+          if (state.data && terminalModes.includes(state.data.mode)) {
+            return;
+          }
+          // Retry SSE after 3s, fall back to polling in the meantime
+          if (!pollFallbackTimer) schedulePoll();
+          setTimeout(() => connectSse(), 3000);
+        };
+      }
+
       function schedulePoll() {
-        setTimeout(async () => {
+        // Only poll if SSE is not connected
+        if (sseConnected) return;
+        const terminalModes = ['abandoned', 'completed', 'session-disconnected'];
+        if (state.data && terminalModes.includes(state.data.mode)) {
+          return;
+        }
+        pollFallbackTimer = setTimeout(async () => {
           try { await refresh(); } catch (_) {}
-          // Stop polling for terminal states
-          const terminalModes = ['abandoned', 'completed', 'session-disconnected'];
-          if (!terminalModes.includes(state.data?.mode)) schedulePoll();
+          pollFallbackTimer = null;
+          if (!sseConnected) {
+            schedulePoll();
+          }
         }, 2500);
       }
 
       refresh().catch((error) => {
         document.getElementById('submitStatus').textContent = error.message || 'Failed to load interview.';
       });
-      schedulePoll();
+      connectSse();
     </script>
   </body>
 </html>`;
@@ -27232,6 +27752,51 @@ function createDashboardServer(config) {
   let baseUrl = null;
   const sessions = new Map;
   const stateCache = new Map;
+  const sseClients = new Map;
+  function formatSseState(entry) {
+    const markdownPath = entry.filePath;
+    const displayPath = markdownPath ? markdownPath.split("/").pop() || markdownPath : "interview.md";
+    const document = entry.document ?? "";
+    return {
+      interview: {
+        id: entry.interviewId,
+        sessionID: entry.sessionID,
+        idea: entry.idea,
+        markdownPath: displayPath,
+        createdAt: new Date(entry.lastUpdatedAt).toISOString(),
+        status: entry.mode === "session-disconnected" ? "abandoned" : "active",
+        baseMessageCount: 0
+      },
+      url: `${baseUrl}/interview/${entry.interviewId}`,
+      markdownPath,
+      mode: entry.mode,
+      isBusy: entry.mode === "awaiting-agent",
+      summary: entry.summary,
+      questions: entry.questions,
+      document,
+      lastUpdatedAt: entry.lastUpdatedAt,
+      nudgeAction: entry.nudgeAction,
+      blocks: entry.blocks ?? parseSpecBlocks(document)
+    };
+  }
+  function broadcastSse(interviewId, entry) {
+    const clients = sseClients.get(interviewId);
+    if (!clients || clients.size === 0)
+      return;
+    const payload = `event: state
+data: ${JSON.stringify(formatSseState(entry))}
+
+`;
+    for (const res of clients) {
+      try {
+        res.write(payload);
+      } catch {
+        clients.delete(res);
+      }
+    }
+    if (clients.size === 0)
+      sseClients.delete(interviewId);
+  }
   const TERMINAL_MODES = new Set([
     "abandoned",
     "completed",
@@ -27390,7 +27955,9 @@ function createDashboardServer(config) {
           pendingAnswers: null,
           lastUpdatedAt: fm.updatedAt ? new Date(fm.updatedAt).getTime() : Date.now(),
           filePath: path14.join(interviewDir, entry),
-          nudgeAction: null
+          nudgeAction: null,
+          pendingBlockComment: null,
+          pendingChatMessage: null
         });
         if (!sessions.has(fm.sessionID)) {
           sessions.set(fm.sessionID, {
@@ -27571,7 +28138,9 @@ function createDashboardServer(config) {
         pendingAnswers: null,
         lastUpdatedAt: Date.now(),
         filePath: "",
-        nudgeAction: null
+        nudgeAction: null,
+        pendingBlockComment: null,
+        pendingChatMessage: null
       });
       dedupRecovered(interviewId, stateCache);
       fileCache = null;
@@ -27582,6 +28151,48 @@ function createDashboardServer(config) {
       });
       return;
     }
+    if (request.method === "GET" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/events")) {
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/events", "");
+      if (!interviewId || !isValidId(interviewId)) {
+        sendJson(response, 400, { error: "Invalid interview ID" });
+        return;
+      }
+      const entry = stateCache.get(interviewId);
+      if (!entry) {
+        sendJson(response, 404, { error: "Interview not found" });
+        return;
+      }
+      response.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+        "access-control-allow-origin": "*"
+      });
+      let clients = sseClients.get(interviewId);
+      if (!clients) {
+        clients = new Set;
+        sseClients.set(interviewId, clients);
+      }
+      clients.add(response);
+      response.write(`event: state
+data: ${JSON.stringify(formatSseState(entry))}
+
+`);
+      const heartbeat = setInterval(() => {
+        try {
+          response.write(`: hb
+
+`);
+        } catch {}
+      }, 15000);
+      request.on("close", () => {
+        clearInterval(heartbeat);
+        clients?.delete(response);
+        if (clients && clients.size === 0)
+          sseClients.delete(interviewId);
+      });
+      return;
+    }
     if (request.method === "POST" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/state")) {
       const interviewId = pathname.replace("/api/interviews/", "").replace("/state", "");
       if (!interviewId || !isValidId(interviewId)) {
@@ -27608,10 +28219,15 @@ function createDashboardServer(config) {
           existing.questions = state.questions;
         if (state.filePath)
           existing.filePath = state.filePath;
+        if (state.document !== undefined)
+          existing.document = state.document;
+        if (state.blocks !== undefined)
+          existing.blocks = state.blocks;
         existing.lastUpdatedAt = Date.now();
         dedupRecovered(interviewId, stateCache);
+        broadcastSse(interviewId, existing);
       } else {
-        stateCache.set(interviewId, {
+        const entry = {
           interviewId,
           sessionID: state.sessionID ?? "",
           idea: state.idea ?? "",
@@ -27622,8 +28238,14 @@ function createDashboardServer(config) {
           pendingAnswers: null,
           lastUpdatedAt: Date.now(),
           filePath: state.filePath ?? "",
-          nudgeAction: null
-        });
+          nudgeAction: null,
+          pendingBlockComment: state.pendingBlockComment ?? null,
+          pendingChatMessage: state.pendingChatMessage ?? null,
+          document: state.document,
+          blocks: state.blocks
+        };
+        stateCache.set(interviewId, entry);
+        broadcastSse(interviewId, entry);
       }
       sendJson(response, 200, { status: "ok" });
       return;
@@ -27681,7 +28303,8 @@ function createDashboardServer(config) {
         questions: entry.questions,
         document,
         lastUpdatedAt: entry.lastUpdatedAt,
-        nudgeAction: entry.nudgeAction
+        nudgeAction: entry.nudgeAction,
+        blocks: parseSpecBlocks(document)
       });
       return;
     }
@@ -27716,12 +28339,12 @@ function createDashboardServer(config) {
       sendJson(response, 200, { status: "ok" });
       return;
     }
-    if (request.method === "GET" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/pending")) {
+    if (request.method === "POST" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/block-comment")) {
       if (!isAuthenticated(request)) {
         sendJson(response, 401, { error: "Unauthorized" });
         return;
       }
-      const interviewId = pathname.replace("/api/interviews/", "").replace("/pending", "");
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/block-comment", "");
       if (!isValidId(interviewId)) {
         sendJson(response, 400, { error: "Invalid interview ID" });
         return;
@@ -27731,12 +28354,126 @@ function createDashboardServer(config) {
         sendJson(response, 404, { error: "Interview not found" });
         return;
       }
-      const answers = entry.pendingAnswers;
-      if (answers) {
-        entry.pendingAnswers = null;
+      let body;
+      try {
+        body = await readJsonBody(request);
+      } catch {
+        sendJson(response, 400, { error: "Invalid JSON" });
+        return;
       }
-      sendJson(response, 200, {
-        answers
+      const { section, comment } = body;
+      if (typeof section !== "string" || typeof comment !== "string") {
+        sendJson(response, 400, {
+          error: "section and comment must be strings"
+        });
+        return;
+      }
+      entry.pendingBlockComment = { section, comment };
+      entry.mode = "awaiting-agent";
+      entry.lastUpdatedAt = Date.now();
+      sendJson(response, 200, { status: "ok" });
+      return;
+    }
+    if (request.method === "GET" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/block-comment")) {
+      if (!isAuthenticated(request)) {
+        sendJson(response, 401, { error: "Unauthorized" });
+        return;
+      }
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/block-comment", "");
+      if (!isValidId(interviewId)) {
+        sendJson(response, 400, { error: "Invalid interview ID" });
+        return;
+      }
+      const entry = stateCache.get(interviewId);
+      if (!entry) {
+        sendJson(response, 404, { error: "Interview not found" });
+        return;
+      }
+      const val = entry.pendingBlockComment;
+      if (val) {
+        entry.pendingBlockComment = null;
+      }
+      sendJson(response, 200, val || {});
+      return;
+    }
+    if (request.method === "POST" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/chat")) {
+      if (!isAuthenticated(request)) {
+        sendJson(response, 401, { error: "Unauthorized" });
+        return;
+      }
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/chat", "");
+      if (!isValidId(interviewId)) {
+        sendJson(response, 400, { error: "Invalid interview ID" });
+        return;
+      }
+      const entry = stateCache.get(interviewId);
+      if (!entry) {
+        sendJson(response, 404, { error: "Interview not found" });
+        return;
+      }
+      let body;
+      try {
+        body = await readJsonBody(request);
+      } catch {
+        sendJson(response, 400, { error: "Invalid JSON" });
+        return;
+      }
+      const { message } = body;
+      if (typeof message !== "string" || !message.trim()) {
+        sendJson(response, 400, {
+          error: "message must be a non-empty string"
+        });
+        return;
+      }
+      entry.pendingChatMessage = message.trim();
+      entry.mode = "awaiting-agent";
+      entry.lastUpdatedAt = Date.now();
+      sendJson(response, 200, { status: "ok" });
+      return;
+    }
+    if (request.method === "GET" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/chat")) {
+      if (!isAuthenticated(request)) {
+        sendJson(response, 401, { error: "Unauthorized" });
+        return;
+      }
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/chat", "");
+      if (!isValidId(interviewId)) {
+        sendJson(response, 400, { error: "Invalid interview ID" });
+        return;
+      }
+      const entry = stateCache.get(interviewId);
+      if (!entry) {
+        sendJson(response, 404, { error: "Interview not found" });
+        return;
+      }
+      const val = entry.pendingChatMessage;
+      if (val) {
+        entry.pendingChatMessage = null;
+      }
+      sendJson(response, 200, { message: val || null });
+      return;
+    }
+    if (request.method === "GET" && pathname.startsWith("/api/interviews/") && pathname.endsWith("/pending")) {
+      if (!isAuthenticated(request)) {
+        sendJson(response, 401, { error: "Unauthorized" });
+        return;
+      }
+      const interviewId = pathname.replace("/api/interviews/", "").replace("/pending", "");
+      if (!isValidId(interviewId)) {
+        sendJson(response, 400, { error: "Invalid interview ID" });
+        return;
+      }
+      const entry = stateCache.get(interviewId);
+      if (!entry) {
+        sendJson(response, 404, { error: "Interview not found" });
+        return;
+      }
+      const answers = entry.pendingAnswers;
+      if (answers) {
+        entry.pendingAnswers = null;
+      }
+      sendJson(response, 200, {
+        answers
       });
       return;
     }
@@ -27885,9 +28622,20 @@ function createDashboardServer(config) {
           entry.pendingAnswers ??= existing.pendingAnswers;
         if (existing.nudgeAction)
           entry.nudgeAction ??= existing.nudgeAction;
+        if (existing.pendingBlockComment)
+          entry.pendingBlockComment ??= existing.pendingBlockComment;
+        if (existing.pendingChatMessage)
+          entry.pendingChatMessage ??= existing.pendingChatMessage;
+        if (entry.document === undefined && existing.document !== undefined) {
+          entry.document = existing.document;
+        }
+        if (entry.blocks === undefined && existing.blocks !== undefined) {
+          entry.blocks = existing.blocks;
+        }
       }
       stateCache.set(entry.interviewId, entry);
       dedupRecovered(entry.interviewId, stateCache);
+      broadcastSse(entry.interviewId, entry);
     },
     getState: (id) => stateCache.get(id),
     storeAnswers: (id, answers) => {
@@ -27915,6 +28663,22 @@ function createDashboardServer(config) {
       entry.nudgeAction = null;
       return action;
     },
+    consumeBlockComment: (id) => {
+      const entry = stateCache.get(id);
+      if (!entry?.pendingBlockComment)
+        return null;
+      const comment = entry.pendingBlockComment;
+      entry.pendingBlockComment = null;
+      return comment;
+    },
+    consumeChatMessage: (id) => {
+      const entry = stateCache.get(id);
+      if (!entry?.pendingChatMessage)
+        return null;
+      const message = entry.pendingChatMessage;
+      entry.pendingChatMessage = null;
+      return message;
+    },
     authToken,
     discoverSessionDirectories,
     addManualFolder: (dir) => {
@@ -28102,6 +28866,50 @@ function createInterviewServer(deps) {
       }
       return;
     }
+    const blockCommentMatch = pathname.match(/^\/api\/interviews\/([^/]+)\/block-comment$/);
+    if (request.method === "POST" && blockCommentMatch) {
+      try {
+        const body = await readJsonBody(request);
+        if (typeof body.section !== "string" || typeof body.comment !== "string") {
+          sendJson(response, 400, {
+            error: "section and comment must be strings"
+          });
+          return;
+        }
+        await deps.submitBlockComment(decodeURIComponent(blockCommentMatch[1]), body.section, body.comment);
+        sendJson(response, 200, {
+          ok: true,
+          message: "Block feedback forwarded."
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to submit block comment.";
+        const status = getSubmissionStatus(error);
+        sendJson(response, status, { ok: false, message });
+      }
+      return;
+    }
+    const chatMatch = pathname.match(/^\/api\/interviews\/([^/]+)\/chat$/);
+    if (request.method === "POST" && chatMatch) {
+      try {
+        const body = await readJsonBody(request);
+        if (typeof body.message !== "string" || !body.message.trim()) {
+          sendJson(response, 400, {
+            error: "message must be a non-empty string"
+          });
+          return;
+        }
+        await deps.submitChat(decodeURIComponent(chatMatch[1]), body.message.trim());
+        sendJson(response, 200, {
+          ok: true,
+          message: "Chat message forwarded to agent."
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to submit chat message.";
+        const status = getSubmissionStatus(error);
+        sendJson(response, status, { ok: false, message });
+      }
+      return;
+    }
     const nudgeMatch = pathname.match(/^\/api\/interviews\/([^/]+)\/nudge$/);
     if (request.method === "POST" && nudgeMatch) {
       try {
@@ -28216,6 +29024,39 @@ function normalizeQuestion(value, index) {
     suggested: typeof result.data.suggested === "string" && result.data.suggested.trim().length > 0 ? result.data.suggested.trim() : undefined
   };
 }
+function repairJsonNewlines(json) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0;i < json.length; i++) {
+    const char = json[i];
+    if (inString) {
+      if (escaped) {
+        result += char;
+        escaped = false;
+      } else if (char === "\\") {
+        result += char;
+        escaped = true;
+      } else if (char === '"') {
+        result += char;
+        inString = false;
+      } else if (char === `
+`) {
+        result += "\\n";
+      } else if (char === "\r") {
+        result += "\\r";
+      } else {
+        result += char;
+      }
+    } else {
+      if (char === '"') {
+        inString = true;
+      }
+      result += char;
+    }
+  }
+  return result;
+}
 function flattenMessage(message) {
   return (message.parts ?? []).map((part) => part.text ?? "").join(`
 `).trim();
@@ -28232,8 +29073,14 @@ function parseAssistantState(text, maxQuestions = 2) {
   if (!match) {
     return { state: null };
   }
+  let rawJson = match[1].trim();
   try {
-    const raw = JSON.parse(match[1]);
+    JSON.parse(rawJson);
+  } catch {
+    rawJson = repairJsonNewlines(rawJson);
+  }
+  try {
+    const raw = JSON.parse(rawJson);
     const parsed = RawInterviewStateSchema.parse(raw);
     const summary = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
     const title = typeof parsed.title === "string" && parsed.title.trim().length > 0 ? parsed.title.trim() : undefined;
@@ -28291,17 +29138,67 @@ ${suggested}`;
 
 `);
 }
+var SPECIFICATION_TEMPLATE_GUIDELINE = `
+Your target document MUST be structured strictly using the following 11-section template (exclude the frontmatter itself from the summary JSON field, as the tool handles frontmatter automatically):
+
+# Introduction
+[Short intro to the spec and goals]
+
+## 1. Purpose & Scope
+[Intended audience, boundaries, and assumptions]
+
+## 2. Definitions
+[Acronyms, terms defined]
+
+## 3. Requirements, Constraints & Guidelines
+[Explicitly list requirements using:
+- **REQ-001**: Description
+- **SEC-001**: Security constraints
+- **CON-001**: System constraints/technologies
+- **GUD-001**: Guidelines]
+
+## 4. Interfaces & Data Contracts
+[APIs, JSON schemas, protocol buffers, or class/data structures]
+
+## 5. Acceptance Criteria
+[Define testable criteria in Given-When-Then format:
+- **AC-001**: Given [context], When [action], Then [expected outcome]]
+
+## 6. Test Automation Strategy
+[Mocking approach, test framework, unit/integration details]
+
+## 7. Rationale & Context
+[Trade-offs and architectural decisions]
+
+## 8. Dependencies & External Integrations
+[Conceptual integrations or external dependencies:
+- **EXT-001**: Dependency details]
+
+## 9. Examples & Edge Cases
+[Concrete code examples, settings, or JSON structures]
+
+## 10. Validation Criteria
+[Testing or validation check logic]
+
+## 11. Related Specifications / Further Reading
+[Internal doc references]
+
+ANTI-ASSUMPTION & SUB-AGENT DELEGATION RULE:
+Do not invent file structures, API signatures, package lists, or library behaviors. If you need to trace local code, verify file paths, or check configurations, you MUST call the sub-agent '@explorer' or search files directly. If you need to search documentation or web info for external APIs/libraries, you MUST call the sub-agent '@librarian' or search the web. Do not guess. Pause, run discovery, and integrate facts into the spec.
+`;
 function buildKickoffPrompt(idea, maxQuestions) {
   return [
     "You are running an interview q&a session for the user inside their repository.",
     `Initial idea: ${idea}`,
+    `Goal: Iteratively generate and populate a highly structured Specification document.`,
+    SPECIFICATION_TEMPLATE_GUIDELINE,
     `Clarify the idea through short rounds of at most ${maxQuestions} questions at a time.`,
     "When useful, each question may include 2 to 4 answer options and one suggested option.",
     "Be practical. Focus on the highest-ambiguity and highest-risk decisions first.",
     "After any short human-friendly preface, you MUST include a machine-readable block in this exact format:",
     "<interview_state>",
     "{",
-    '  "summary": "one short paragraph about the current understanding",',
+    '  "summary": "Full specification markdown (strictly matching the 11 section titles above)",',
     '  "title": "concise-kebab-case-title-for-filename",',
     '  "questions": [',
     "    {",
@@ -28315,7 +29212,7 @@ function buildKickoffPrompt(idea, maxQuestions) {
     "</interview_state>",
     "Rules:",
     `- Return 0 to ${maxQuestions} questions.`,
-    "- If there are no more useful questions, return zero questions.",
+    "- If there are no more useful questions or the specification is complete, return zero questions.",
     `- Do not ask more than ${maxQuestions} questions in one round.`,
     '- Provide a concise "title" field (kebab-case, 3-6 words) suitable for a filename.'
   ].join(`
@@ -28325,12 +29222,13 @@ function buildResumePrompt(document, maxQuestions) {
   return [
     "Resume the interview from this existing markdown document.",
     "Use the current spec and Q&A history as ground truth so far.",
+    SPECIFICATION_TEMPLATE_GUIDELINE,
     "Do not restart from scratch.",
     "",
     document,
     "",
     `Ask the next highest-value clarifying questions, up to ${maxQuestions} at a time.`,
-    "If there are no more useful questions, return zero questions.",
+    "If there are no more useful questions or the spec is complete, return zero questions.",
     "Return the same <interview_state> JSON block format as before."
   ].join(`
 `);
@@ -28340,12 +29238,13 @@ function buildAnswerPrompt(answers, questions, maxQuestions) {
 `);
   return [
     "Continue the same interview.",
+    SPECIFICATION_TEMPLATE_GUIDELINE,
     "These were the active questions:",
     formatQuestionContext(questions),
     "The user answered:",
     answerText,
-    "Now update your understanding and ask the next highest-value clarifying questions.",
-    `Return 0 to ${maxQuestions} questions. If there are no more useful questions, return zero questions.`,
+    "Now update the specification summary document and ask the next highest-value clarifying questions.",
+    `Return 0 to ${maxQuestions} questions. If there are no more useful questions or the spec is complete, return zero questions.`,
     "Return the same <interview_state> JSON block format as before."
   ].join(`
 
@@ -28405,6 +29304,7 @@ function createInterviewService(ctx, config, deps) {
   const browserOpener = deps?.openBrowser ?? openBrowser;
   const activeInterviewIds = new Map;
   const interviewsById = new Map;
+  const activeSyncs = new Map;
   const sessionBusy = new Map;
   const sessionModel = new Map;
   const browserOpened = new Set;
@@ -28477,6 +29377,19 @@ function createInterviewService(ctx, config, deps) {
     });
     return result.data;
   }
+  async function loadMessagesWithRetry(sessionID) {
+    for (let i = 0;i < 8; i++) {
+      const messages = await loadMessages(sessionID);
+      if (messages.length > 0) {
+        const last = messages[messages.length - 1];
+        if (last?.info?.role === "assistant") {
+          return messages;
+        }
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, 250));
+    }
+    return loadMessages(sessionID);
+  }
   function isUserVisibleMessage(message) {
     return !(message.parts ?? []).some((part) => hasInternalInitiatorMarker(part));
   }
@@ -28545,8 +29458,19 @@ function createInterviewService(ctx, config, deps) {
     }
     return record;
   }
-  async function syncInterview(interview) {
-    const allMessages = await loadMessages(interview.sessionID);
+  function syncInterview(interview) {
+    const existing = activeSyncs.get(interview.id);
+    if (existing) {
+      return existing;
+    }
+    const sync = performSyncInterview(interview).finally(() => {
+      activeSyncs.delete(interview.id);
+    });
+    activeSyncs.set(interview.id, sync);
+    return sync;
+  }
+  async function performSyncInterview(interview) {
+    const allMessages = await loadMessagesWithRetry(interview.sessionID);
     const interviewMessages = allMessages.slice(interview.baseMessageCount).filter(isUserVisibleMessage);
     const parsed = findLatestAssistantState(interviewMessages, maxQuestions);
     const existingDocument = await readInterviewDocument(interview);
@@ -28556,17 +29480,24 @@ function createInterviewService(ctx, config, deps) {
       summary: extractSummarySection(existingDocument) || fallbackState.summary
     };
     await maybeRenameWithTitle(interview, state.title);
-    const document = await rewriteInterviewDocument(interview, state.summary);
+    let document;
+    if (parsed.state) {
+      document = await rewriteInterviewDocument(interview, state.summary);
+    } else {
+      document = await readInterviewDocument(interview);
+    }
+    const blocks = parseSpecBlocks(document);
     const interviewState = {
       interview,
       url: `${await ensureServer()}/interview/${interview.id}`,
       markdownPath: relativeInterviewPath(ctx.directory, interview.markdownPath),
-      mode: interview.status === "abandoned" ? "abandoned" : parsed.state && state.questions.length === 0 ? "completed" : sessionBusy.get(interview.sessionID) === true ? "awaiting-agent" : state.questions.length > 0 ? "awaiting-user" : parsed.latestAssistantError ? "error" : "awaiting-agent",
+      mode: interview.status === "abandoned" ? "abandoned" : parsed.state && state.questions.length === 0 ? "completed" : sessionBusy.get(interview.sessionID) === true ? "awaiting-agent" : state.questions.length > 0 ? "awaiting-user" : parsed.latestAssistantError ? "error" : !parsed.state && sessionBusy.get(interview.sessionID) === false ? "completed" : "awaiting-agent",
       lastParseError: parsed.latestAssistantError,
       isBusy: sessionBusy.get(interview.sessionID) === true,
       summary: state.summary,
       questions: state.questions,
-      document
+      document,
+      blocks
     };
     if (onStateChange) {
       onStateChange(interview.id, interviewState);
@@ -28792,6 +29723,105 @@ function createInterviewService(ctx, config, deps) {
     fileCache = { items: sorted, at: Date.now() };
     return sorted;
   }
+  async function submitBlockComment(interviewId, sectionTitle, comment) {
+    const interview = getInterviewById(interviewId);
+    if (!interview) {
+      throw new Error("Interview not found");
+    }
+    if (interview.status === "abandoned") {
+      throw new Error("Interview session is no longer active.");
+    }
+    if (sessionBusy.get(interview.sessionID) === true) {
+      throw new Error("Interview session is busy. Wait for the current response.");
+    }
+    sessionBusy.set(interview.sessionID, true);
+    let promptSent = false;
+    try {
+      const state = await getInterviewState(interviewId);
+      if (state.mode === "error") {
+        throw new Error("Interview is waiting for a valid agent update.");
+      }
+      const relativePath = relativeInterviewPath(ctx.directory, interview.markdownPath);
+      const prompt = [
+        `You are updating the active interview specification document at "${relativePath}".`,
+        `The current document content on disk is:`,
+        `\`\`\`markdown`,
+        state.document,
+        `\`\`\``,
+        ``,
+        `The user submitted specific feedback/comments for the section "${sectionTitle}".`,
+        `Feedback: ${comment}`,
+        ``,
+        `Update the specification summary (focusing heavily on making changes to the "${sectionTitle}" section) to address this feedback.`,
+        `If this feedback implies other parts of the spec should change, update them too.`,
+        `Include the updated 11-section specification and ask the next highest-value clarifying questions as questions (up to ${maxQuestions} questions) if needed.`,
+        `Return the same <interview_state> JSON block format as before.`
+      ].join(`
+`);
+      const model = sessionModel.get(interview.sessionID);
+      await ctx.client.session.promptAsync({
+        path: { id: interview.sessionID },
+        body: {
+          parts: [createInternalAgentTextPart(prompt)],
+          ...model ? { model: parseModelReference(model) ?? undefined } : {}
+        }
+      });
+      promptSent = true;
+    } finally {
+      if (!promptSent) {
+        sessionBusy.set(interview.sessionID, false);
+      }
+    }
+  }
+  async function submitChat(interviewId, message) {
+    const interview = getInterviewById(interviewId);
+    if (!interview) {
+      throw new Error("Interview not found");
+    }
+    if (interview.status === "abandoned") {
+      throw new Error("Interview session is no longer active.");
+    }
+    if (sessionBusy.get(interview.sessionID) === true) {
+      throw new Error("Interview session is busy. Wait for the current response.");
+    }
+    sessionBusy.set(interview.sessionID, true);
+    let promptSent = false;
+    try {
+      const state = await getInterviewState(interviewId);
+      if (state.mode === "error") {
+        throw new Error("Interview is waiting for a valid agent update.");
+      }
+      const relativePath = relativeInterviewPath(ctx.directory, interview.markdownPath);
+      const prompt = [
+        `You are continuing the interview for the specification document at "${relativePath}".`,
+        `The current document content on disk is:`,
+        `\`\`\`markdown`,
+        state.document,
+        `\`\`\``,
+        ``,
+        `The user sent a freeform message via the dashboard chat panel:`,
+        `${message}`,
+        ``,
+        `Process this request — it may be a request to add a new section, revise existing content, ask clarifying questions, or make structural changes.`,
+        `Update the specification document accordingly and include the updated 11-section specification.`,
+        `Ask up to ${maxQuestions} clarifying questions if needed using the same <interview_state> JSON block format as before.`
+      ].join(`
+`);
+      const model = sessionModel.get(interview.sessionID);
+      await ctx.client.session.promptAsync({
+        path: { id: interview.sessionID },
+        body: {
+          parts: [createInternalAgentTextPart(prompt)],
+          ...model ? { model: parseModelReference(model) ?? undefined } : {}
+        }
+      });
+      promptSent = true;
+    } finally {
+      if (!promptSent) {
+        sessionBusy.set(interview.sessionID, false);
+      }
+    }
+  }
   async function handleNudgeAction(interviewId, action) {
     const interview = getInterviewById(interviewId);
     if (!interview) {
@@ -28807,12 +29837,17 @@ function createInterviewService(ctx, config, deps) {
     let promptSent = false;
     try {
       const state = await getInterviewState(interviewId);
+      const relativePath = relativeInterviewPath(ctx.directory, interview.markdownPath);
       let prompt;
       if (action === "more-questions") {
         prompt = [
-          `The user reviewed the completed interview spec and wants you to continue.`,
+          `You are continuing the interview for the specification document at "${relativePath}".`,
+          `The current document content on disk is:`,
+          `\`\`\`markdown`,
+          state.document,
+          `\`\`\``,
           ``,
-          `Current spec summary: ${state.summary}`,
+          `The user reviewed the completed interview spec and wants you to continue.`,
           ``,
           `Ask up to ${maxQuestions} new clarifying questions about aspects that are still unclear or underspecified.`,
           `Include the structured <interview_state> block with new questions.`
@@ -28820,9 +29855,13 @@ function createInterviewService(ctx, config, deps) {
 `);
       } else {
         prompt = [
-          `The user confirmed the interview spec is complete.`,
+          `You are finishing the interview for the specification document at "${relativePath}".`,
+          `The current document content on disk is:`,
+          `\`\`\`markdown`,
+          state.document,
+          `\`\`\``,
           ``,
-          `Current spec summary: ${state.summary}`,
+          `The user confirmed the interview spec is complete.`,
           ``,
           `Produce a final, polished version of the full spec document.`,
           `Do NOT include any <interview_state> block — just output the final spec as clean markdown.`,
@@ -28857,6 +29896,8 @@ function createInterviewService(ctx, config, deps) {
     listInterviewFiles,
     listInterviews,
     submitAnswers,
+    submitBlockComment,
+    submitChat,
     handleNudgeAction
   };
 }
@@ -28875,6 +29916,8 @@ function createInterviewManager(ctx, config) {
       listInterviewFiles: async () => service2.listInterviewFiles(),
       listInterviews: () => service2.listInterviews(),
       submitAnswers: async (interviewId, answers) => service2.submitAnswers(interviewId, answers),
+      submitBlockComment: async (interviewId, section, comment) => service2.submitBlockComment(interviewId, section, comment),
+      submitChat: async (interviewId, message) => service2.submitChat(interviewId, message),
       handleNudgeAction: async (interviewId, action) => service2.handleNudgeAction(interviewId, action),
       outputFolder: resolvedOutputPath,
       port: 0
@@ -28908,6 +29951,8 @@ function createInterviewManager(ctx, config) {
           continue;
         pollPendingAnswers(sessionID).catch(() => {});
         pollNudgeAction(sessionID).catch(() => {});
+        pollBlockComment(sessionID).catch(() => {});
+        pollChat(sessionID).catch(() => {});
       }
     }, FALLBACK_POLL_INTERVAL);
     fallbackTimer?.unref();
@@ -28939,7 +29984,9 @@ function createInterviewManager(ctx, config) {
             pendingAnswers: null,
             lastUpdatedAt: Date.now(),
             filePath: interview.markdownPath,
-            nudgeAction: null
+            nudgeAction: null,
+            pendingBlockComment: null,
+            pendingChatMessage: null
           });
           dashboard?.registerSession({
             sessionID: interview.sessionID,
@@ -28965,122 +30012,140 @@ function createInterviewManager(ctx, config) {
           await new Promise((r) => setTimeout(r, 500));
           const retry = await probeDashboard(dashboardPort);
           if (!retry.alive) {
-            log("[interview] dashboard mode: no dashboard found, falling back to per-session server", {
-              port: dashboardPort
-            });
-            const perSessionServer = createInterviewServer({
-              getState: async (interviewId) => service.getInterviewState(interviewId),
-              listInterviewFiles: async () => service.listInterviewFiles(),
-              listInterviews: () => service.listInterviews(),
-              submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
-              handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
-              outputFolder: path16.join(ctx.directory, outputFolder),
-              port: 0
-            });
-            service.setBaseUrlResolver(() => perSessionServer.ensureStarted());
-            isDashboard = false;
-            initDone = true;
-            return;
+            log("[interview] dashboard probe failed twice, falling back to local server");
+            throw new Error("Dashboard not reachable");
           }
         }
+        const creds = await readDashboardAuthFile(dashboardPort);
+        if (!creds) {
+          throw new Error("Dashboard credentials file missing");
+        }
         dashboardBaseUrl = `http://127.0.0.1:${dashboardPort}`;
-        const auth = await readDashboardAuthFile(dashboardPort);
-        authToken = auth?.token ?? "";
+        authToken = creds.token;
         service.setBaseUrlResolver(() => Promise.resolve(dashboardBaseUrl));
         service.setStatePushCallback((id, state) => {
-          pushStateViaHttp(dashboardBaseUrl, authToken, id, state).catch((err) => {
-            log("[interview] failed to push state to dashboard", {
-              error: err instanceof Error ? err.message : String(err)
+          if (dashboardBaseUrl && authToken) {
+            pushStateViaHttp(dashboardBaseUrl, authToken, id, state).catch((err) => {
+              log("[interview] failed to push state to dashboard:", {
+                error: err instanceof Error ? err.message : String(err)
+              });
             });
-          });
+          }
         });
         service.setOnInterviewCreated((interview) => {
-          registerInterviewViaHttp(dashboardBaseUrl, authToken, interview).catch((err) => {
-            log("[interview] failed to register interview with dashboard", {
-              error: err instanceof Error ? err.message : String(err)
+          if (dashboardBaseUrl && authToken) {
+            registerInterviewViaHttp(dashboardBaseUrl, authToken, interview).catch((err) => {
+              log("[interview] failed to register interview with dashboard:", {
+                error: err instanceof Error ? err.message : String(err)
+              });
             });
-          });
+          }
         });
-        log("[interview] dashboard mode: we are a session", {
-          port: dashboardPort
+        log("[interview] dashboard mode: registered as session client", {
+          dashboardUrl: dashboardBaseUrl
         });
-        startFallbackTimer();
       }
     } catch (err) {
-      log("[interview] dashboard mode init failed", {
-        error: err instanceof Error ? err.message : String(err)
+      log("[interview] dashboard election failed or unreachable. Falling back to per-session server.", { error: err instanceof Error ? err.message : String(err) });
+      isDashboard = false;
+      const resolvedOutputPath = path16.join(ctx.directory, outputFolder);
+      const server = createInterviewServer({
+        getState: async (interviewId) => service.getInterviewState(interviewId),
+        listInterviewFiles: async () => service.listInterviewFiles(),
+        listInterviews: () => service.listInterviews(),
+        submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
+        submitBlockComment: async (interviewId, section, comment) => service.submitBlockComment(interviewId, section, comment),
+        submitChat: async (interviewId, message) => service.submitChat(interviewId, message),
+        handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
+        outputFolder: resolvedOutputPath,
+        port: 0
       });
+      service.setBaseUrlResolver(() => server.ensureStarted());
+      service.setStatePushCallback(() => {});
     } finally {
       initDone = true;
     }
   })();
-  async function ensureInit() {
-    if (!initDone)
+  async function ensureInitialized() {
+    if (!initDone) {
       await initPromise;
+    }
   }
-  async function registerSessionIfNeeded(sessionID) {
-    if (registeredSessions.has(sessionID))
-      return;
-    registeredSessions.add(sessionID);
-    if (isDashboard)
+  async function pollPendingAnswers(sessionID) {
+    const interviewId = service.getActiveInterviewId(sessionID);
+    if (!interviewId)
       return;
     try {
-      await fetch(`${dashboardBaseUrl}/api/register?token=${authToken}`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          sessionID,
-          directory: ctx.directory,
-          pid: process.pid
-        }),
-        signal: AbortSignal.timeout(3000)
-      });
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/pending?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const body = await res.json();
+      if (res.ok && body.answers && body.answers.length > 0) {
+        log("[interview] delivering pending answers (HTTP poll)", {
+          interviewId,
+          count: body.answers.length
+        });
+        await service.submitAnswers(interviewId, body.answers);
+      }
     } catch (err) {
-      log("[interview] failed to register session with dashboard", {
+      log("[interview] failed polling pending answers:", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  async function pollPendingAnswers(sessionID) {
+  async function pollNudgeAction(sessionID) {
     const interviewId = service.getActiveInterviewId(sessionID);
     if (!interviewId)
       return;
     try {
-      const response = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/pending?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
-      if (!response.ok)
-        return;
-      const data = await response.json();
-      if (!data.answers || data.answers.length === 0)
-        return;
-      log("[interview] delivering pending answers from dashboard", {
-        interviewId,
-        count: data.answers.length
-      });
-      await service.submitAnswers(interviewId, data.answers);
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/nudge?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const body = await res.json();
+      if (res.ok && body.action) {
+        log("[interview] delivering nudge action (HTTP poll)", {
+          interviewId,
+          action: body.action
+        });
+        await service.handleNudgeAction(interviewId, body.action);
+      }
     } catch (err) {
-      log("[interview] failed to poll pending answers", {
+      log("[interview] failed polling nudge action:", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  async function pollNudgeAction(sessionID) {
+  async function pollBlockComment(sessionID) {
     const interviewId = service.getActiveInterviewId(sessionID);
     if (!interviewId)
       return;
     try {
-      const response = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/nudge?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
-      if (!response.ok)
-        return;
-      const data = await response.json();
-      if (!data.action)
-        return;
-      log("[interview] delivering nudge action from dashboard", {
-        interviewId,
-        action: data.action
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/block-comment?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const body = await res.json();
+      if (res.ok && body.section && body.comment) {
+        log("[interview] delivering block comment (HTTP poll)", {
+          interviewId,
+          section: body.section
+        });
+        await service.submitBlockComment(interviewId, body.section, body.comment);
+      }
+    } catch (err) {
+      log("[interview] failed polling block comment:", {
+        error: err instanceof Error ? err.message : String(err)
       });
-      await service.handleNudgeAction(interviewId, data.action);
+    }
+  }
+  async function pollChat(sessionID) {
+    const interviewId = service.getActiveInterviewId(sessionID);
+    if (!interviewId)
+      return;
+    try {
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/chat?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const body = await res.json();
+      if (res.ok && body.message) {
+        log("[interview] delivering chat message (HTTP poll)", {
+          interviewId
+        });
+        await service.submitChat(interviewId, body.message);
+      }
     } catch (err) {
-      log("[interview] failed to poll nudge action", {
+      log("[interview] failed polling chat message:", {
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -29088,28 +30153,39 @@ function createInterviewManager(ctx, config) {
   return {
     registerCommand: (c) => service.registerCommand(c),
     handleCommandExecuteBefore: async (input, output) => {
-      await ensureInit();
-      await service.handleCommandExecuteBefore(input, output);
-      if (input.sessionID) {
-        await registerSessionIfNeeded(input.sessionID);
+      await ensureInitialized();
+      const sessionID = input.sessionID;
+      registeredSessions.add(sessionID);
+      if (!isDashboard && dashboardBaseUrl) {
+        fetch(`${dashboardBaseUrl}/api/sessions?token=${authToken}`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            sessionID,
+            directory: ctx.directory,
+            pid: process.pid
+          }),
+          signal: AbortSignal.timeout(3000)
+        }).catch(() => {});
+        startFallbackTimer();
       }
+      await service.handleCommandExecuteBefore(input, output);
     },
     handleEvent: async (input) => {
-      await ensureInit();
-      await service.handleEvent(input);
+      await ensureInitialized();
       const { event } = input;
       const properties = event.properties ?? {};
-      const sessionID = properties.sessionID;
-      if (sessionID) {
-        await registerSessionIfNeeded(sessionID);
-      }
-      if (event.type === "session.status" && sessionID) {
+      const sessionID = properties.sessionID ?? null;
+      await service.handleEvent(input);
+      if (event.type === "session.status") {
         const status = properties.status;
-        if (status?.type === "idle") {
+        if (sessionID && status?.type === "idle") {
           const interviewId = service.getActiveInterviewId(sessionID);
-          if (!isDashboard) {
+          if (!isDashboard && dashboardBaseUrl) {
             await pollPendingAnswers(sessionID);
             await pollNudgeAction(sessionID);
+            await pollBlockComment(sessionID);
+            await pollChat(sessionID);
           } else if (interviewId && dashboard) {
             const pending = dashboard.consumePendingAnswers(interviewId);
             if (pending && pending.length > 0) {
@@ -29127,6 +30203,21 @@ function createInterviewManager(ctx, config) {
               });
               await service.handleNudgeAction(interviewId, nudge);
             }
+            const comment = dashboard.consumeBlockComment(interviewId);
+            if (comment) {
+              log("[interview] delivering block comment (in-process)", {
+                interviewId,
+                section: comment.section
+              });
+              await service.submitBlockComment(interviewId, comment.section, comment.comment);
+            }
+            const chat = dashboard.consumeChatMessage(interviewId);
+            if (chat) {
+              log("[interview] delivering chat message (in-process)", {
+                interviewId
+              });
+              await service.submitChat(interviewId, chat);
+            }
           }
           if (interviewId) {
             service.getInterviewState(interviewId).catch((err) => {
@@ -29161,7 +30252,11 @@ function stateToEntry(interviewId, state) {
     pendingAnswers: null,
     lastUpdatedAt: Date.now(),
     filePath: state.interview.markdownPath,
-    nudgeAction: null
+    nudgeAction: null,
+    pendingBlockComment: null,
+    pendingChatMessage: null,
+    document: state.document,
+    blocks: state.blocks
   };
 }
 async function pushStateViaHttp(dashboardUrl, token, interviewId, state) {
@@ -29180,9 +30275,23 @@ async function registerInterviewViaHttp(dashboardUrl, token, interview) {
     body: JSON.stringify({
       interviewId: interview.id,
       sessionID: interview.sessionID,
-      idea: interview.idea
+      idea: interview.idea,
+      mode: "awaiting-agent",
+      summary: "Interview created.",
+      title: interview.idea,
+      questions: [],
+      pendingAnswers: null,
+      lastUpdatedAt: Date.now(),
+      filePath: interview.markdownPath,
+      nudgeAction: null,
+      pendingBlockComment: null,
+      pendingChatMessage: null
     }),
     signal: AbortSignal.timeout(3000)
+  }).catch((err) => {
+    log("[interview] failed to register interview with dashboard via HTTP:", {
+      error: err instanceof Error ? err.message : String(err)
+    });
   });
 }
 // src/mcp/context7.ts
@@ -29940,7 +31049,6 @@ function startAvailabilityCheck(config) {
   }
 }
 // src/multiplexer/session-manager.ts
-var SESSION_MISSING_GRACE_MS = POLL_INTERVAL_BACKGROUND_MS * 3;
 var SHARED_STATE_KEY = Symbol.for("oh-my-opencode-slim.multiplexer-session-manager.state");
 function getSharedState() {
   const globalWithState = globalThis;
@@ -29948,7 +31056,8 @@ function getSharedState() {
     sessions: new Map,
     knownSessions: new Map,
     spawningSessions: new Set,
-    closingSessions: new Map
+    closingSessions: new Map,
+    deferredIdleCloses: new Set
   };
   return globalWithState[SHARED_STATE_KEY];
 }
@@ -29962,6 +31071,7 @@ class MultiplexerSessionManager {
   knownSessions;
   spawningSessions;
   closingSessions;
+  deferredIdleCloses;
   pollInterval;
   enabled = false;
   constructor(ctx, config, backgroundJobBoard) {
@@ -29971,6 +31081,7 @@ class MultiplexerSessionManager {
     this.knownSessions = sharedState.knownSessions;
     this.spawningSessions = sharedState.spawningSessions;
     this.closingSessions = sharedState.closingSessions;
+    this.deferredIdleCloses = sharedState.deferredIdleCloses;
     this.directory = ctx.directory;
     const defaultPort = process.env.OPENCODE_PORT ?? "4096";
     this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`;
@@ -30052,17 +31163,13 @@ class MultiplexerSessionManager {
         }));
         return;
       }
-      const now = Date.now();
       this.sessions.set(sessionId, {
         sessionId,
         paneId: paneResult.paneId,
         parentId,
         title,
         directory,
-        ownerInstanceId: this.instanceId,
-        createdAt: now,
-        lastSeenAt: now,
-        seenInStatus: false
+        ownerInstanceId: this.instanceId
       });
       log("[multiplexer-session-manager] pane spawned", {
         instanceId: this.instanceId,
@@ -30097,7 +31204,8 @@ class MultiplexerSessionManager {
     const sessionId = event.properties?.sessionID;
     if (!sessionId)
       return;
-    if (event.properties?.status?.type === "idle") {
+    const statusType = event.properties?.status?.type;
+    if (statusType === "idle") {
       log("[multiplexer-session-manager] session status idle received", {
         instanceId: this.instanceId,
         sessionId,
@@ -30109,7 +31217,10 @@ class MultiplexerSessionManager {
       await this.closeSession(sessionId, "idle");
       return;
     }
-    if (event.properties?.status?.type === "busy") {
+    if (statusType) {
+      this.deferredIdleCloses.delete(sessionId);
+      if (statusType !== "busy")
+        return;
       log("[multiplexer-session-manager] session busy event received", {
         instanceId: this.instanceId,
         sessionId,
@@ -30137,6 +31248,7 @@ class MultiplexerSessionManager {
       ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
       backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
     });
+    this.deferredIdleCloses.delete(sessionId);
     await this.closeSession(sessionId, "deleted");
   }
   startPolling() {
@@ -30163,7 +31275,6 @@ class MultiplexerSessionManager {
     }
     try {
       const allStatuses = await this.fetchSessionStatuses();
-      const now = Date.now();
       const sessionsToClose = [];
       for (const [sessionId, tracked] of this.sessions.entries()) {
         if (tracked.ownerInstanceId !== this.instanceId) {
@@ -30176,34 +31287,16 @@ class MultiplexerSessionManager {
           continue;
         }
         const status = allStatuses[sessionId];
-        const isIdle = status?.type === "idle";
-        if (status) {
-          tracked.lastSeenAt = now;
-          tracked.seenInStatus = true;
-          tracked.missingSince = undefined;
-        } else if (!tracked.missingSince) {
-          tracked.missingSince = now;
-        }
-        const missingTooLong = !!tracked.missingSince && now - tracked.missingSince >= SESSION_MISSING_GRACE_MS;
-        const shouldKeepRunningBackgroundJob = (isIdle || missingTooLong) && this.isRunningBackgroundJob(sessionId);
-        if (isIdle || missingTooLong) {
-          if (shouldKeepRunningBackgroundJob) {
-            log("[multiplexer-session-manager] keeping running background pane", {
-              instanceId: this.instanceId,
-              sessionId,
-              paneId: tracked.paneId,
-              seenInStatus: tracked.seenInStatus
-            });
-            continue;
-          }
-          sessionsToClose.push({
-            sessionId,
-            reason: isIdle ? "idle" : "missing"
-          });
+        if (!status)
+          continue;
+        if (status.type !== "idle") {
+          this.deferredIdleCloses.delete(sessionId);
+          continue;
         }
+        sessionsToClose.push(sessionId);
       }
-      for (const { sessionId, reason } of sessionsToClose) {
-        await this.closeSession(sessionId, reason);
+      for (const sessionId of sessionsToClose) {
+        await this.closeSession(sessionId, "idle");
       }
     } catch (err) {
       log("[multiplexer-session-manager] poll error", { error: String(err) });
@@ -30228,6 +31321,7 @@ class MultiplexerSessionManager {
   async closeSession(sessionId, reason) {
     if (reason === "deleted") {
       this.knownSessions.delete(sessionId);
+      this.deferredIdleCloses.delete(sessionId);
     }
     const existingClose = this.closingSessions.get(sessionId);
     if (existingClose)
@@ -30263,6 +31357,7 @@ class MultiplexerSessionManager {
       });
     }
     if (reason === "idle" && this.isRunningBackgroundJob(sessionId)) {
+      this.deferredIdleCloses.add(sessionId);
       log("[multiplexer-session-manager] close skipped; background job running", {
         instanceId: this.instanceId,
         sessionId,
@@ -30272,6 +31367,7 @@ class MultiplexerSessionManager {
       });
       return;
     }
+    this.deferredIdleCloses.delete(sessionId);
     this.sessions.delete(sessionId);
     log("[multiplexer-session-manager] closing session pane", {
       instanceId: this.instanceId,
@@ -30347,18 +31443,15 @@ class MultiplexerSessionManager {
         }));
         return;
       }
-      const now = Date.now();
       this.sessions.set(sessionId, {
         sessionId,
         paneId: paneResult.paneId,
         parentId: known.parentId,
         title: known.title,
         directory: known.directory,
-        ownerInstanceId: this.instanceId,
-        createdAt: now,
-        lastSeenAt: now,
-        seenInStatus: false
+        ownerInstanceId: this.instanceId
       });
+      this.deferredIdleCloses.delete(sessionId);
       log("[multiplexer-session-manager] pane respawned on busy", {
         instanceId: this.instanceId,
         sessionId,
@@ -30385,6 +31478,13 @@ class MultiplexerSessionManager {
   isRunningBackgroundJob(sessionId) {
     return this.backgroundJobBoard?.get(sessionId)?.state === "running";
   }
+  async retryDeferredIdleClose(sessionId) {
+    if (!this.enabled)
+      return;
+    if (!this.deferredIdleCloses.has(sessionId))
+      return;
+    await this.closeSession(sessionId, "idle");
+  }
   async cleanup() {
     this.stopPolling();
     if (this.closingSessions.size > 0) {
@@ -30405,6 +31505,7 @@ class MultiplexerSessionManager {
     this.knownSessions.clear();
     this.spawningSessions.clear();
     this.closingSessions.clear();
+    this.deferredIdleCloses.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -30656,7 +31757,7 @@ function createAcpRunTool(agents = {}) {
       agent: z4.string().describe("Configured ACP agent name"),
       prompt: z4.string().describe("Task or question to send to the ACP agent"),
       cwd: z4.string().optional().describe("Optional absolute working directory override"),
-      timeout_ms: z4.number().int().min(1000).max(900000).optional().describe("Optional timeout override in milliseconds")
+      timeout_ms: z4.number().int().min(0).max(MAX_ACP_TIMEOUT_MS).optional().describe("Optional timeout override in milliseconds. Set to 0 to disable the timeout.")
     },
     async execute(args, ctx) {
       if (ctx.agent !== args.agent) {
@@ -30692,11 +31793,12 @@ function createAcpRunTool(agents = {}) {
       });
       const timeoutMs = args.timeout_ms ?? config.timeoutMs;
       let timer;
-      const timeout = new Promise((_, reject) => timer = setTimeout(() => reject(new Error(`ACP agent '${args.agent}' timed out after ${timeoutMs}ms`)), timeoutMs));
+      const timeout = timeoutMs > 0 ? new Promise((_, reject) => timer = setTimeout(() => reject(new Error(`ACP agent '${args.agent}' timed out after ${timeoutMs}ms`)), timeoutMs)) : undefined;
       const abort = () => client.close();
       ctx.abort.addEventListener("abort", abort, { once: true });
       try {
-        return await Promise.race([client.run(args.prompt), timeout]);
+        const run = client.run(args.prompt);
+        return timeout ? await Promise.race([run, timeout]) : await run;
       } finally {
         if (timer)
           clearTimeout(timer);
@@ -31791,7 +32893,8 @@ function emptySnapshot() {
   return {
     version: 1,
     updatedAt: Date.now(),
-    agentModels: {}
+    agentModels: {},
+    agentVariants: {}
   };
 }
 function parseSnapshot(value) {
@@ -31801,7 +32904,8 @@ function parseSnapshot(value) {
   return {
     version: 1,
     updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
-    agentModels: parsed.agentModels ?? {}
+    agentModels: parsed.agentModels ?? {},
+    agentVariants: parsed.agentVariants ?? {}
   };
 }
 function readTuiSnapshot() {
@@ -31835,11 +32939,19 @@ function updateSnapshot(mutator) {
 function recordTuiAgentModels(input) {
   updateSnapshot((snapshot) => {
     snapshot.agentModels = { ...input.agentModels };
+    snapshot.agentVariants = { ...input.agentVariants ?? {} };
   });
 }
 function recordTuiAgentModel(input) {
   updateSnapshot((snapshot) => {
     snapshot.agentModels[input.agentName] = input.model;
+    if (input.variant !== undefined) {
+      if (input.variant === null) {
+        delete snapshot.agentVariants[input.agentName];
+      } else {
+        snapshot.agentVariants[input.agentName] = input.variant;
+      }
+    }
   });
 }
 
@@ -31911,12 +33023,18 @@ function createPresetManager(ctx, config) {
     } catch {}
     const snapshot = readTuiSnapshot();
     const agentModels = { ...snapshot.agentModels };
+    const agentVariants = { ...snapshot.agentVariants };
     for (const [agentName, agentConfig] of Object.entries(agentUpdates)) {
       if (typeof agentConfig.model === "string") {
         agentModels[agentName] = agentConfig.model;
       }
+      if (typeof agentConfig.variant === "string") {
+        agentVariants[agentName] = agentConfig.variant;
+      } else {
+        delete agentVariants[agentName];
+      }
     }
-    recordTuiAgentModels({ agentModels });
+    recordTuiAgentModels({ agentModels, agentVariants });
     activePreset = presetName;
     const summaryParts = [];
     for (const [name, cfg] of Object.entries(agentUpdates)) {
@@ -34309,6 +35427,16 @@ function createWebfetchTool(pluginCtx, options = {}) {
     }
   });
 }
+// src/utils/env.ts
+var TRUTHY_ENV_VALUES = new Set(["1", "true", "yes", "on"]);
+var PLUGIN_DISABLE_ENV = "OH_MY_OPENCODE_SLIM_DISABLE";
+function isTruthyEnvValue(value) {
+  return TRUTHY_ENV_VALUES.has(value?.trim().toLowerCase() ?? "");
+}
+function isPluginDisabledByEnv(env = process.env) {
+  return isTruthyEnvValue(env[PLUGIN_DISABLE_ENV]);
+}
+
 // src/utils/subagent-depth.ts
 class SubagentDepthTracker {
   depthBySession = new Map;
@@ -34399,6 +35527,10 @@ async function probeJSDOM() {
 var OhMyOpenCodeLite = async (ctx) => {
   const sessionId = new Date().toISOString().replace(/[-:]/g, "").slice(0, 15);
   initLogger(sessionId);
+  if (isPluginDisabledByEnv()) {
+    log("[plugin] disabled by OH_MY_OPENCODE_SLIM_DISABLE");
+    return {};
+  }
   let config;
   let disabledAgents;
   let agentDefs;
@@ -34431,6 +35563,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let cancelTaskTools;
   let acpRunTools;
   let webfetch;
+  let tools;
   let rewriteDisplayNameMentions;
   let toolCount = 0;
   try {
@@ -34482,6 +35615,9 @@ var OhMyOpenCodeLite = async (ctx) => {
       readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? 8
     });
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig, backgroundJobBoard);
+    backgroundJobBoard.setTerminalStateListener((taskID) => {
+      multiplexerSessionManager.retryDeferredIdleClose(taskID);
+    });
     autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
       autoUpdate: config.autoUpdate ?? true,
       companion: config.companion
@@ -34514,7 +35650,19 @@ var OhMyOpenCodeLite = async (ctx) => {
       backgroundJobBoard,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
     });
-    toolCount = Object.keys(councilTools).length + Object.keys(cancelTaskTools).length + Object.keys(acpRunTools).length + 1 + 2;
+    tools = {
+      ...councilTools,
+      ...cancelTaskTools,
+      ...acpRunTools,
+      webfetch,
+      ast_grep_search,
+      ast_grep_replace
+    };
+    if (config.disabled_tools && config.disabled_tools.length > 0) {
+      const disabledTools = new Set(config.disabled_tools);
+      tools = Object.fromEntries(Object.entries(tools).filter(([name]) => !disabledTools.has(name)));
+    }
+    toolCount = Object.keys(tools).length;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
     await appLog(ctx, "error", `INIT FAILED: ${String(err)}. Report at github.com/alvinunreal/oh-my-opencode-slim/issues/310`);
@@ -34567,17 +35715,25 @@ var OhMyOpenCodeLite = async (ctx) => {
     }
   }
   companionManager.onLoad();
+  function resolveTuiVariantForModel(agentName, model) {
+    const configEntry = config.agents?.[agentName];
+    const defaultVariant = typeof configEntry?.variant === "string" ? configEntry.variant : undefined;
+    const chainMatches = modelArrayMap[agentName]?.filter((entry) => entry.id === model);
+    if (chainMatches) {
+      if (chainMatches.length === 1) {
+        return chainMatches[0].variant ?? defaultVariant;
+      }
+      return;
+    }
+    if (typeof configEntry?.model === "string" && configEntry.model === model && defaultVariant) {
+      return defaultVariant;
+    }
+    return;
+  }
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
-    tool: {
-      ...councilTools,
-      ...cancelTaskTools,
-      ...acpRunTools,
-      webfetch,
-      ast_grep_search,
-      ast_grep_replace
-    },
+    tool: tools,
     mcp: mcps,
     config: async (opencodeConfig) => {
       if (config.setDefaultAgent !== false && !opencodeConfig.default_agent) {
@@ -34703,14 +35859,22 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
       }
       const tuiAgentModels = {};
+      const tuiAgentVariants = {};
       for (const agentDef of agentDefs) {
         if (agentDef.name === "councillor")
           continue;
         const entry = configAgent[agentDef.name];
         const resolvedModel = typeof entry?.model === "string" ? entry.model : runtimeChains[agentDef.name]?.[0] ? runtimeChains[agentDef.name][0] : typeof agentDef.config.model === "string" ? agentDef.config.model : undefined;
+        const resolvedVariant = typeof entry?.variant === "string" ? entry.variant : typeof agentDef.config.variant === "string" ? agentDef.config.variant : undefined;
         tuiAgentModels[agentDef.name] = resolvedModel ?? "default";
+        if (resolvedVariant) {
+          tuiAgentVariants[agentDef.name] = resolvedVariant;
+        }
       }
-      recordTuiAgentModels({ agentModels: tuiAgentModels });
+      recordTuiAgentModels({
+        agentModels: tuiAgentModels,
+        agentVariants: tuiAgentVariants
+      });
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
         opencodeConfig.mcp = { ...mcps };
@@ -34748,10 +35912,16 @@ var OhMyOpenCodeLite = async (ctx) => {
       const event = input.event;
       if (event.type === "message.updated") {
         const info = event.properties?.info;
-        if (typeof info?.agent === "string" && typeof info.providerID === "string" && typeof info.modelID === "string") {
+        const providerID = typeof info?.providerID === "string" ? info.providerID : typeof info?.model?.providerID === "string" ? info.model.providerID : undefined;
+        const modelID = typeof info?.modelID === "string" ? info.modelID : typeof info?.model?.modelID === "string" ? info.model.modelID : undefined;
+        if (typeof info?.agent === "string" && providerID && modelID) {
+          const agentName = resolveRuntimeAgentName(config, info.agent);
+          const model = `${providerID}/${modelID}`;
+          const variant = resolveTuiVariantForModel(agentName, model);
           recordTuiAgentModel({
-            agentName: resolveRuntimeAgentName(config, info.agent),
-            model: `${info.providerID}/${info.modelID}`
+            agentName,
+            model,
+            variant: variant ?? null
           });
         }
       }