oh-my-opencode-slim 0.9.5 → 0.9.7

package/dist/index.js

@@ -1,4 +1,194 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/agents/orchestrator.ts
+var exports_orchestrator = {};
+__export(exports_orchestrator, {
+  resolvePrompt: () => resolvePrompt,
+  createOrchestratorAgent: () => createOrchestratorAgent,
+  ORCHESTRATOR_PROMPT: () => ORCHESTRATOR_PROMPT
+});
+function resolvePrompt(base, customPrompt, customAppendPrompt) {
+  if (customPrompt)
+    return customPrompt;
+  if (customAppendPrompt)
+    return `${base}
+
+${customAppendPrompt}`;
+  return base;
+}
+function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(ORCHESTRATOR_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "orchestrator",
+    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+var ORCHESTRATOR_PROMPT = `<Role>
+You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
+</Role>
+
+<Agents>
+
+@explorer
+- Role: Parallel search specialist for discovering unknowns across the codebase
+- Stats: 3x faster codebase search than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
+- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
+- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
+
+@librarian
+- Role: Authoritative source for current library docs and API references
+- Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
+- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
+- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
+- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
+
+@oracle
+- Role: Strategic advisor for high-stakes decisions and persistent problems, code reviewer
+- Stats: 5x better decision maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
+- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging, code review, simplification, maintainability review
+- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high \u2022 When a workflow calls for a **reviewer** subagent \u2022 Code needs simplification or YAGNI scrutiny
+- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
+- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Need code review or simplification? \u2192 @oracle. Just do it and PR? \u2192 yourself.
+
+@designer
+- Role: UI/UX specialist for intentional, polished experiences
+- Stats: 10x better UI/UX than orchestrator
+- Capabilities: Visual relevant edits, interactions, responsive layouts, design systems with aesthetic intent, deep UI/UX knowledge; can edits files directly
+- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful \u2022 Reviewing existing UI/UX quality
+- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
+- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
+
+@fixer
+- Role: Fast execution specialist for well-defined tasks, which empowers orchestrator with parallel, speedy executions
+- Stats: 2x faster code edits, 1/2 cost of orchestrator, 0.8x quality of orchestrator
+- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
+- **Delegate when:** For implementation work, think and triage first. If the change is non-trivial or multi-file, hand bounded execution to @fixer \u2022 Writing or updating tests \u2022 Tasks that touch test files, fixtures, mocks, or test helpers
+- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining to fixer > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
+- **Rule of thumb:** Explaining > doing? \u2192 yourself. Test file modifications and bounded implementation work usually go to @fixer. Orchestrator paths selection is vastly improved by Fixer. eg it can reduce overall speed if Orchestrator splits what's usually a single task into multiple subtasks and parallelize it with fixer.
+
+@council
+- Role: Multi-LLM consensus engine for high-confidence answers
+- Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
+- Capabilities: Runs multiple models in parallel, synthesizes their responses via a council master
+- **Delegate when:** Critical decisions needing diverse model perspectives \u2022 High-stakes architectural choices where consensus reduces risk \u2022 Ambiguous problems where multi-model disagreement is informative \u2022 Security-sensitive design reviews
+- **Don't delegate when:** Straightforward tasks you're confident about \u2022 Speed matters more than confidence \u2022 Single-model answer is sufficient \u2022 Routine implementation work
+- **Result handling:** Present the council's synthesized response verbatim. Do not re-summarize \u2014 the council master has already produced the final answer.
+- **Rule of thumb:** Need second/third opinions from different models? \u2192 @council. One good answer enough? \u2192 yourself.
+
+</Agents>
+
+<Workflow>
+
+## 1. Understand
+Parse request: explicit requirements + implicit needs.
+
+## 2. Path Selection
+Evaluate approach by: quality, speed, cost, reliability.
+Choose the path that optimizes all four.
+
+## 3. Delegation Check
+**STOP. Review specialists before acting.**
+
+!!! Review available agents and delegation rules. Decide whether to delegate or do it yourself. !!!
+
+**Delegation efficiency:**
+- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
+- Provide context summaries, let specialists read what they need
+- Brief user on delegation goal before each call
+- Skip delegation if overhead \u2265 doing it yourself
+
+## 4. Split and Parallelize
+Can tasks be split into subtasks and run in parallel?
+- Multiple @explorer searches across different domains?
+- @explorer + @librarian research in parallel?
+- Multiple @fixer instances for faster, scoped implementation?
+
+Balance: respect dependencies, avoid parallelizing what must be sequential.
+
+## 5. Execute
+1. Break complex tasks into todos
+2. Fire parallel research/implementation
+3. Delegate to specialists or do it yourself based on step 3
+4. Integrate results
+5. Adjust if needed
+
+### Auto-Continue
+When working through multi-step tasks, consider enabling auto-continue to avoid stopping between batches:
+- **Enable when:** User requests autonomous/batch work, or you create 4+ todos in a session
+- **Don't enable when:** User is in an interactive/conversational flow, or each step needs explicit review
+- Use the \`auto_continue\` tool with \`enabled: true\` to activate. The system will automatically resume you when incomplete todos remain after you stop.
+- The user can toggle this anytime via the \`/auto-continue\` command.
+
+### Validation routing
+- Validation is a workflow stage owned by the Orchestrator, not a separate specialist
+- Route UI/UX validation and review to @designer
+- Route code review, simplification, maintainability review, and YAGNI checks to @oracle
+- Route test writing, test updates, and changes touching test files to @fixer
+- If a request spans multiple lanes, delegate only the lanes that add clear value
+
+## 6. Verify
+- Run \`lsp_diagnostics\` for errors
+- Use validation routing when applicable instead of doing all review work yourself
+- If test files are involved, prefer @fixer for bounded test changes and @oracle only for test strategy or quality review
+- Confirm specialists completed successfully
+- Verify solution meets requirements
+
+</Workflow>
+
+<Communication>
+
+## Clarity Over Assumptions
+- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
+- Don't guess at critical details (file paths, API choices, architectural decisions)
+- Do make reasonable assumptions for minor details and state them briefly
+
+## Concise Execution
+- Answer directly, no preamble
+- Don't summarize what you did unless asked
+- Don't explain code unless asked
+- One-word answers are fine when appropriate
+- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
+
+## No Flattery
+Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
+
+## Honest Pushback
+When user's approach seems problematic:
+- State concern + alternative concisely
+- Ask if they want to proceed anyway
+- Don't lecture, don't blindly implement
+
+## Example
+**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
+
+**Good:** "Checking Next.js App Router docs via @librarian..."
+[proceeds with implementation]
+
+</Communication>
+`;
+
 // src/cli/paths.ts
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -341,6 +531,11 @@ var McpNameSchema = z2.enum(["websearch", "context7", "grep_app"]);
 var BackgroundTaskConfigSchema = z2.object({
   maxConcurrentStarts: z2.number().min(1).max(50).default(10)
 });
+var InterviewConfigSchema = z2.object({
+  maxQuestions: z2.number().int().min(1).max(10).default(2),
+  outputFolder: z2.string().min(1).default("interview"),
+  autoOpenBrowser: z2.boolean().default(true)
+});
 var TodoContinuationConfigSchema = z2.object({
   maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
   cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
@@ -367,6 +562,7 @@ var PluginConfigSchema = z2.object({
   tmux: TmuxConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
   background: BackgroundTaskConfigSchema.optional(),
+  interview: InterviewConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
@@ -442,6 +638,7 @@ function loadPluginConfig(directory) {
       agents: deepMerge(config.agents, projectConfig.agents),
       tmux: deepMerge(config.tmux, projectConfig.tmux),
       multiplexer: deepMerge(config.multiplexer, projectConfig.multiplexer),
+      interview: deepMerge(config.interview, projectConfig.interview),
       fallback: deepMerge(config.fallback, projectConfig.fallback),
       council: deepMerge(config.council, projectConfig.council)
     };
@@ -568,221 +765,48 @@ async function extractSessionResult(client, sessionId, options) {
   return { text, empty: text.length === 0 };
 }
 
-// src/agents/orchestrator.ts
-function resolvePrompt(base, customPrompt, customAppendPrompt) {
-  if (customPrompt)
-    return customPrompt;
-  if (customAppendPrompt)
-    return `${base}
-
-${customAppendPrompt}`;
-  return base;
-}
-var ORCHESTRATOR_PROMPT = `<Role>
-You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
-</Role>
+// src/agents/council.ts
+var COUNCIL_AGENT_PROMPT = `You are the Council agent \u2014 a multi-LLM orchestration system that runs consensus across multiple models.
 
-<Agents>
+**Tool**: You have access to the \`council_session\` tool.
 
-@explorer
-- Role: Parallel search specialist for discovering unknowns across the codebase
-- Stats: 3x faster codebase search than orchestrator, 1/2 cost of orchestrator
-- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
-- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
-- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
+**When to use**:
+- When invoked by a user with a request
+- When you want multiple expert opinions on a complex problem
+- When higher confidence is needed through model consensus
 
-@librarian
-- Role: Authoritative source for current library docs and API references
-- Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
-- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
-- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
-- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
-- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
+**Usage**:
+1. Call the \`council_session\` tool with the user's prompt
+2. Optionally specify a preset (default: "default")
+3. Receive the synthesized response from the council master
+4. Present the result to the user
 
-@oracle
-- Role: Strategic advisor for high-stakes decisions and persistent problems, code reviewer
-- Stats: 5x better decision maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
-- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging, code review, simplification, maintainability review
-- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high \u2022 When a workflow calls for a **reviewer** subagent \u2022 Code needs simplification or YAGNI scrutiny
-- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
-- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Need code review or simplification? \u2192 @oracle. Just do it and PR? \u2192 yourself.
+**Behavior**:
+- Delegate requests directly to council_session
+- Don't pre-analyze or filter the prompt
+- Present the synthesized result verbatim \u2014 do not re-summarize or condense
+- Briefly explain the consensus if requested`;
+function createCouncilAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCIL_AGENT_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "council",
+    description: "Multi-LLM council agent that synthesizes responses from multiple models for higher-quality outputs",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+function formatCouncillorPrompt(userPrompt, councillorPrompt) {
+  if (!councillorPrompt)
+    return userPrompt;
+  return `${councillorPrompt}
 
-@designer
-- Role: UI/UX specialist for intentional, polished experiences
-- Stats: 10x better UI/UX than orchestrator
-- Capabilities: Visual direction, interactions, responsive layouts, design systems with aesthetic intent, UI/UX review
-- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful \u2022 Reviewing existing UI/UX quality
-- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
-- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
-
-@fixer
-- Role: Fast execution specialist for well-defined tasks, which empowers orchestrator with parallel, speedy executions
-- Stats: 2x faster code edits, 1/2 cost of orchestrator, 0.8x quality of orchestrator
-- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
-- **Delegate when:** For implementation work, think and triage first. If the change is non-trivial or multi-file, hand bounded execution to @fixer \u2022 Writing or updating tests \u2022 Tasks that touch test files, fixtures, mocks, or test helpers
-- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining to fixer > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
-- **Rule of thumb:** Explaining > doing? \u2192 yourself. Test file modifications and bounded implementation work usually go to @fixer. Orchestrator paths selection is vastly improved by Fixer. eg it can reduce overall speed if Orchestrator splits what's usually a single task into multiple subtasks and parallelize it with fixer.
-
-@council
-- Role: Multi-LLM consensus engine for high-confidence answers
-- Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
-- Capabilities: Runs multiple models in parallel, synthesizes their responses via a council master
-- **Delegate when:** Critical decisions needing diverse model perspectives \u2022 High-stakes architectural choices where consensus reduces risk \u2022 Ambiguous problems where multi-model disagreement is informative \u2022 Security-sensitive design reviews
-- **Don't delegate when:** Straightforward tasks you're confident about \u2022 Speed matters more than confidence \u2022 Single-model answer is sufficient \u2022 Routine implementation work
-- **Result handling:** Present the council's synthesized response verbatim. Do not re-summarize \u2014 the council master has already produced the final answer.
-- **Rule of thumb:** Need second/third opinions from different models? \u2192 @council. One good answer enough? \u2192 yourself.
-
-</Agents>
-
-<Workflow>
-
-## 1. Understand
-Parse request: explicit requirements + implicit needs.
-
-## 2. Path Selection
-Evaluate approach by: quality, speed, cost, reliability.
-Choose the path that optimizes all four.
-
-## 3. Delegation Check
-**STOP. Review specialists before acting.**
-
-!!! Review available agents and delegation rules. Decide whether to delegate or do it yourself. !!!
-
-**Delegation efficiency:**
-- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
-- Provide context summaries, let specialists read what they need
-- Brief user on delegation goal before each call
-- Skip delegation if overhead \u2265 doing it yourself
-
-## 4. Split and Parallelize
-Can tasks be split into subtasks and run in parallel?
-- Multiple @explorer searches across different domains?
-- @explorer + @librarian research in parallel?
-- Multiple @fixer instances for faster, scoped implementation?
-
-Balance: respect dependencies, avoid parallelizing what must be sequential.
-
-## 5. Execute
-1. Break complex tasks into todos
-2. Fire parallel research/implementation
-3. Delegate to specialists or do it yourself based on step 3
-4. Integrate results
-5. Adjust if needed
-
-### Auto-Continue
-When working through multi-step tasks, consider enabling auto-continue to avoid stopping between batches:
-- **Enable when:** User requests autonomous/batch work, or you create 4+ todos in a session
-- **Don't enable when:** User is in an interactive/conversational flow, or each step needs explicit review
-- Use the \`auto_continue\` tool with \`enabled: true\` to activate. The system will automatically resume you when incomplete todos remain after you stop.
-- The user can toggle this anytime via the \`/auto-continue\` command.
-
-### Validation routing
-- Validation is a workflow stage owned by the Orchestrator, not a separate specialist
-- Route UI/UX validation and review to @designer
-- Route code review, simplification, maintainability review, and YAGNI checks to @oracle
-- Route test writing, test updates, and changes touching test files to @fixer
-- If a request spans multiple lanes, delegate only the lanes that add clear value
-
-## 6. Verify
-- Run \`lsp_diagnostics\` for errors
-- Use validation routing when applicable instead of doing all review work yourself
-- If test files are involved, prefer @fixer for bounded test changes and @oracle only for test strategy or quality review
-- Confirm specialists completed successfully
-- Verify solution meets requirements
-
-</Workflow>
-
-<Communication>
-
-## Clarity Over Assumptions
-- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
-- Don't guess at critical details (file paths, API choices, architectural decisions)
-- Do make reasonable assumptions for minor details and state them briefly
-
-## Concise Execution
-- Answer directly, no preamble
-- Don't summarize what you did unless asked
-- Don't explain code unless asked
-- One-word answers are fine when appropriate
-- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
-
-## No Flattery
-Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
-
-## Honest Pushback
-When user's approach seems problematic:
-- State concern + alternative concisely
-- Ask if they want to proceed anyway
-- Don't lecture, don't blindly implement
-
-## Example
-**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
-
-**Good:** "Checking Next.js App Router docs via @librarian..."
-[proceeds with implementation]
-
-</Communication>
-`;
-function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
-  const prompt = resolvePrompt(ORCHESTRATOR_PROMPT, customPrompt, customAppendPrompt);
-  const definition = {
-    name: "orchestrator",
-    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
-    config: {
-      temperature: 0.1,
-      prompt
-    }
-  };
-  if (Array.isArray(model)) {
-    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
-  } else if (typeof model === "string" && model) {
-    definition.config.model = model;
-  }
-  return definition;
-}
-
-// src/agents/council.ts
-var COUNCIL_AGENT_PROMPT = `You are the Council agent \u2014 a multi-LLM orchestration system that runs consensus across multiple models.
-
-**Tool**: You have access to the \`council_session\` tool.
-
-**When to use**:
-- When invoked by a user with a request
-- When you want multiple expert opinions on a complex problem
-- When higher confidence is needed through model consensus
-
-**Usage**:
-1. Call the \`council_session\` tool with the user's prompt
-2. Optionally specify a preset (default: "default")
-3. Receive the synthesized response from the council master
-4. Present the result to the user
-
-**Behavior**:
-- Delegate requests directly to council_session
-- Don't pre-analyze or filter the prompt
-- Present the synthesized result verbatim \u2014 do not re-summarize or condense
-- Briefly explain the consensus if requested`;
-function createCouncilAgent(model, customPrompt, customAppendPrompt) {
-  const prompt = resolvePrompt(COUNCIL_AGENT_PROMPT, customPrompt, customAppendPrompt);
-  const definition = {
-    name: "council",
-    description: "Multi-LLM council agent that synthesizes responses from multiple models for higher-quality outputs",
-    config: {
-      temperature: 0.1,
-      prompt
-    }
-  };
-  if (model) {
-    definition.config.model = model;
-  }
-  return definition;
-}
-function formatCouncillorPrompt(userPrompt, councillorPrompt) {
-  if (!councillorPrompt)
-    return userPrompt;
-  return `${councillorPrompt}
-
----
+---
 
 ${userPrompt}`;
 }
@@ -3259,7 +3283,7 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
     return;
   }
   invalidatePackage(PACKAGE_NAME);
-  const installSuccess = await runBunInstallSafe(ctx);
+  const installSuccess = await runBunInstallSafe();
   if (installSuccess) {
     showToast(ctx, "OMO-Slim Updated!", `v${currentVersion} \u2192 v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
@@ -3269,10 +3293,14 @@ Restart OpenCode to apply.`, "success", 8000);
     log("[auto-update-checker] bun install failed; update not installed");
   }
 }
-async function runBunInstallSafe(ctx) {
+function getAutoUpdateInstallDir() {
+  return CACHE_DIR;
+}
+async function runBunInstallSafe() {
   try {
+    const installDir = getAutoUpdateInstallDir();
     const proc = Bun.spawn(["bun", "install"], {
-      cwd: ctx.directory,
+      cwd: installDir,
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -3996,196 +4024,1657 @@ function createTodoContinuationHook(ctx, config) {
           const lastText = lastAssistantMessage.parts.map((p) => p.text ?? "").join(" ");
           lastAssistantIsQuestion = isQuestion(lastText);
         }
-        log(`[${HOOK_NAME}] Fetched messages`, {
-          sessionID,
-          lastAssistantIsQuestion
-        });
-      } catch (error) {
-        log(`[${HOOK_NAME}] Warning: failed to fetch messages`, {
-          sessionID,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return;
+        log(`[${HOOK_NAME}] Fetched messages`, {
+          sessionID,
+          lastAssistantIsQuestion
+        });
+      } catch (error) {
+        log(`[${HOOK_NAME}] Warning: failed to fetch messages`, {
+          sessionID,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+      if (lastAssistantIsQuestion) {
+        log(`[${HOOK_NAME}] Skipped: last message is question`, {
+          sessionID
+        });
+        return;
+      }
+      if (state.consecutiveContinuations >= maxContinuations) {
+        log(`[${HOOK_NAME}] Skipped: max continuations reached`, {
+          sessionID,
+          consecutive: state.consecutiveContinuations,
+          max: maxContinuations
+        });
+        return;
+      }
+      const now = Date.now();
+      if (now < state.suppressUntil) {
+        log(`[${HOOK_NAME}] Skipped: in suppress window`, {
+          sessionID,
+          suppressUntil: state.suppressUntil
+        });
+        return;
+      }
+      if (state.pendingTimer !== null || state.isAutoInjecting) {
+        log(`[${HOOK_NAME}] Skipped: timer pending or injection in flight`, {
+          sessionID
+        });
+        return;
+      }
+      log(`[${HOOK_NAME}] Scheduling continuation`, {
+        sessionID,
+        delayMs: cooldownMs
+      });
+      ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          noReply: true,
+          parts: [
+            {
+              type: "text",
+              text: [
+                `\u2394 Auto-continue: ${incompleteCount} incomplete todos remaining \u2014 resuming in ${cooldownMs / 1000}s \u2014 Esc\xD72 to cancel`,
+                "",
+                "[system status: continue without acknowledging this notification]"
+              ].join(`
+`)
+            }
+          ]
+        }
+      }).catch(() => {});
+      state.pendingTimer = setTimeout(async () => {
+        state.pendingTimer = null;
+        if (!state.enabled) {
+          log(`[${HOOK_NAME}] Cancelled: disabled during cooldown`, {
+            sessionID
+          });
+          return;
+        }
+        state.isAutoInjecting = true;
+        try {
+          await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [createInternalAgentTextPart(CONTINUATION_PROMPT)]
+            }
+          });
+          state.consecutiveContinuations++;
+          log(`[${HOOK_NAME}] Continuation injected`, {
+            sessionID,
+            consecutive: state.consecutiveContinuations
+          });
+        } catch (error) {
+          log(`[${HOOK_NAME}] Error: failed to inject continuation`, {
+            sessionID,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        } finally {
+          state.isAutoInjecting = false;
+        }
+      }, cooldownMs);
+    } else if (event.type === "session.status") {
+      const status = properties.status;
+      const sessionID = properties.sessionID;
+      if (status?.type === "busy") {
+        const isOrchestrator = sessionID === state.orchestratorSessionId;
+        if (isOrchestrator) {
+          cancelPendingTimer(state);
+        }
+        if (!state.isAutoInjecting && isOrchestrator && state.consecutiveContinuations > 0) {
+          state.consecutiveContinuations = 0;
+          log(`[${HOOK_NAME}] Reset consecutive count on user activity`, {
+            sessionID
+          });
+        }
+      }
+    } else if (event.type === "session.error") {
+      const error = properties.error;
+      const sessionID = properties.sessionID;
+      const errorName = error?.name;
+      const isOrchestrator = sessionID === state.orchestratorSessionId;
+      if (isOrchestrator && (errorName === "MessageAbortedError" || errorName === "AbortError")) {
+        state.suppressUntil = Date.now() + SUPPRESS_AFTER_ABORT_MS;
+        log(`[${HOOK_NAME}] Suppressed continuation after abort`, {
+          sessionID,
+          errorName
+        });
+      }
+      if (isOrchestrator) {
+        cancelPendingTimer(state);
+        log(`[${HOOK_NAME}] Cancelled pending timer on error`, {
+          sessionID
+        });
+      }
+    } else if (event.type === "session.deleted") {
+      const deletedSessionId = properties.info?.id ?? properties.sessionID;
+      if (state.orchestratorSessionId === deletedSessionId) {
+        cancelPendingTimer(state);
+        log(`[${HOOK_NAME}] Cancelled pending timer on orchestrator delete`, {
+          sessionID: deletedSessionId
+        });
+        resetState(state);
+        state.orchestratorSessionId = null;
+        log(`[${HOOK_NAME}] Reset orchestrator session on delete`, {
+          sessionID: deletedSessionId
+        });
+      }
+    }
+  }
+  async function handleCommandExecuteBefore(input, output) {
+    if (input.command !== COMMAND_NAME) {
+      return;
+    }
+    if (!state.orchestratorSessionId) {
+      state.orchestratorSessionId = input.sessionID;
+    }
+    output.parts.length = 0;
+    const arg = input.arguments.trim().toLowerCase();
+    let newEnabled;
+    if (arg === "on") {
+      newEnabled = true;
+    } else if (arg === "off") {
+      newEnabled = false;
+    } else {
+      newEnabled = !state.enabled;
+    }
+    state.enabled = newEnabled;
+    state.consecutiveContinuations = 0;
+    if (!newEnabled) {
+      cancelPendingTimer(state);
+      output.parts.push(createInternalAgentTextPart("[Auto-continue: disabled by user command.]"));
+      log(`[${HOOK_NAME}] Disabled via /${COMMAND_NAME} command`);
+      return;
+    }
+    state.suppressUntil = 0;
+    log(`[${HOOK_NAME}] Enabled via /${COMMAND_NAME} command`, {
+      maxContinuations
+    });
+    let hasIncompleteTodos = false;
+    try {
+      const todosResult = await ctx.client.session.todo({
+        path: { id: input.sessionID }
+      });
+      const todos = todosResult.data;
+      hasIncompleteTodos = todos.some((t) => !TERMINAL_TODO_STATUSES.includes(t.status));
+    } catch (error) {
+      log(`[${HOOK_NAME}] Warning: failed to fetch todos in command hook`, {
+        sessionID: input.sessionID,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (hasIncompleteTodos) {
+      output.parts.push(createInternalAgentTextPart(`${CONTINUATION_PROMPT} [Auto-continue enabled: up to ${maxContinuations} continuations.]`));
+    } else {
+      output.parts.push(createInternalAgentTextPart(`[Auto-continue: enabled for up to ${maxContinuations} continuations. No incomplete todos right now.]`));
+    }
+  }
+  return {
+    tool: { auto_continue: autoContinue },
+    handleEvent,
+    handleCommandExecuteBefore
+  };
+}
+// src/interview/server.ts
+import {
+  createServer
+} from "http";
+import { URL as URL2 } from "url";
+
+// src/interview/ui.ts
+function renderInterviewPage(interviewId) {
+  const safeTitle = interviewId.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Interview ${safeTitle}</title>
+    <style>
+      :root { color-scheme: dark; }
+      body { 
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; 
+        margin: 0; 
+        background: #000000; 
+        color: #ffffff; 
+        line-height: 1.6;
+        -webkit-font-smoothing: antialiased;
+        font-size: 16px;
+      }
+      .wrap { max-width: 680px; margin: 0 auto; padding: 56px 24px; }
+      .brand-header {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 16px;
+        margin-bottom: 32px;
+        text-align: center;
+      }
+      .brand-mark {
+        width: 144px;
+        height: 144px;
+        object-fit: contain;
+        filter: drop-shadow(0 10px 30px rgba(255,255,255,0.1));
+      }
+      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; }
+      p { margin-top: 0; }
+      .muted { color: rgba(255,255,255,0.5); font-size: 16px; }
+      .meta { display: flex; align-items: center; justify-content: space-between; font-size: 13px; color: rgba(255,255,255,0.4); margin-bottom: 16px; letter-spacing: 0.05em; text-transform: uppercase; }
+      
+      .file-path-container {
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        font-size: 13px;
+        color: rgba(255,255,255,0.6);
+        background: rgba(255,255,255,0.05);
+        padding: 8px 12px;
+        border-radius: 6px;
+        margin-bottom: 36px;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        border: 1px solid rgba(255,255,255,0.08);
+      }
+      .file-path-icon {
+        opacity: 0.5;
+      }
+      
+      .question { 
+        background: rgba(255,255,255,0.02); 
+        border: 1px solid rgba(255,255,255,0.1); 
+        border-left: 1px solid rgba(255,255,255,0.1);
+        border-radius: 6px; 
+        padding: 28px; 
+        margin-bottom: 32px; 
+        transition: all 0.3s cubic-bezier(0.2, 0.8, 0.2, 1);
+      }
+      .question:focus-within {
+        border-color: rgba(255,255,255,0.3);
+      }
+      
+      /* Make active question much clearer */
+      .question.active-question {
+        background: rgba(255,255,255,0.04);
+        border-color: rgba(255,255,255,0.4);
+        border-left: 4px solid #ffffff;
+        box-shadow: 0 8px 32px rgba(0,0,0,0.4), 0 0 0 1px rgba(255,255,255,0.1);
+        transform: translateX(4px);
+      }
+      
+      .options { display: flex; flex-direction: column; gap: 10px; margin-bottom: 20px; }
+      
+      .option { 
+        border: 1px solid rgba(255,255,255,0.1); 
+        background: transparent; 
+        color: inherit; 
+        border-radius: 6px; 
+        padding: 14px 18px; 
+        cursor: pointer; 
+        text-align: left;
+        font-size: 16px;
+        transition: all 0.2s ease;
+        display: flex;
+        align-items: center;
+      }
+      .option:hover {
+        background: rgba(255,255,255,0.06);
+        border-color: rgba(255,255,255,0.3);
+      }
+      .option.selected { 
+        background: #ffffff; 
+        color: #000000; 
+        border-color: #ffffff; 
+        font-weight: 500;
+      }
+      
+      .shortcut {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        background: rgba(255,255,255,0.1);
+        color: rgba(255,255,255,0.8);
+        border-radius: 4px;
+        min-width: 20px;
+        height: 20px;
+        padding: 0 4px;
+        font-size: 12px;
+        margin-right: 12px;
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+      }
+      .option.selected .shortcut {
+        background: rgba(0,0,0,0.15);
+        color: rgba(0,0,0,0.9);
+      }
+       
+      .option-text {
+        flex: 1;
+        line-height: 1.4;
+      }
+
+      .recommended-badge {
+        font-size: 11px;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        background: rgba(255,255,255,0.15);
+        color: rgba(255,255,255,0.9);
+        padding: 4px 8px;
+        border-radius: 999px;
+        margin-left: 12px;
+        font-weight: 600;
+      }
+      .option.selected .recommended-badge {
+        background: rgba(0,0,0,0.15);
+        color: rgba(0,0,0,0.8);
+      }
+
+      .submit-shortcut {
+        display: inline-block;
+        margin-left: 10px;
+        padding: 3px 8px;
+        border-radius: 999px;
+        background: rgba(0,0,0,0.08);
+        color: rgba(0,0,0,0.7);
+        font-size: 12px;
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+      }
+      
+      textarea { 
+        width: 100%; 
+        box-sizing: border-box;
+        min-height: 140px; 
+        border-radius: 6px; 
+        border: 1px solid rgba(255,255,255,0.15); 
+        background: rgba(0,0,0,0.6); 
+        color: inherit; 
+        padding: 16px; 
+        font-family: inherit;
+        font-size: 16px;
+        line-height: 1.5;
+        resize: vertical;
+        outline: none;
+        transition: border-color 0.2s ease;
+      }
+      textarea:focus {
+        border-color: rgba(255,255,255,0.5);
+        box-shadow: 0 0 0 1px rgba(255,255,255,0.1);
+      }
+
+      .hidden-textarea {
+        display: none;
+      }
+      
+      button.primary { 
+        background: #ffffff; 
+        color: #000000; 
+        border: 0; 
+        border-radius: 6px; 
+        padding: 16px 24px; 
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer; 
+        width: 100%;
+        transition: opacity 0.2s ease, transform 0.1s ease;
+      }
+      button.primary:hover:not(:disabled) {
+        opacity: 0.9;
+        transform: translateY(-1px);
+      }
+      button.primary:active:not(:disabled) {
+        transform: translateY(1px);
+      }
+      button.primary:disabled { 
+        opacity: 0.3; 
+        cursor: not-allowed; 
+      }
+      
+      .footer {
+        margin-top: 32px;
+        text-align: center;
+        font-size: 13px;
+        color: rgba(255,255,255,0.4);
+      }
+
+      /* Loading State Overlay */
+      .loading-overlay {
+        position: fixed;
+        top: 0; left: 0; right: 0; bottom: 0;
+        background: rgba(0, 0, 0, 0.85);
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        z-index: 100;
+        opacity: 0;
+        pointer-events: none;
+        backdrop-filter: blur(8px);
+        transition: opacity 0.3s ease;
+      }
+      .loading-overlay.active {
+        opacity: 1;
+        pointer-events: all;
+      }
+      
+      .loading-overlay .status-text {
+        font-size: 15px;
+        letter-spacing: 0.1em;
+        text-transform: uppercase;
+        color: #ffffff;
+        font-weight: 500;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="wrap">
+      <div class="brand-header">
+        <svg
+          class="brand-mark"
+          viewBox="0 0 144 144"
+          role="img"
+          aria-label="Oh My Opencode Slim"
+        >
+          <rect
+            x="12"
+            y="12"
+            width="120"
+            height="120"
+            rx="32"
+            fill="rgba(255,255,255,0.08)"
+            stroke="rgba(255,255,255,0.18)"
+            stroke-width="2"
+          />
+          <path
+            d="M50 48h18c16 0 26 10 26 24s-10 24-26 24H50z"
+            fill="none"
+            stroke="white"
+            stroke-width="8"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          />
+          <path
+            d="M74 48h20c10 0 18 8 18 18v12c0 10-8 18-18 18H74"
+            fill="none"
+            stroke="white"
+            stroke-width="8"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+            opacity="0.65"
+          />
+        </svg>
+      </div>
+      <h1 id="idea">Connecting...</h1>
+      <p class="muted" id="summary">Preparing interview session</p>
+      
+      <div class="meta">
+        <span id="status">INITIALIZING</span>
+        <span>OH MY OPENCODE SLIM</span>
+      </div>
+      
+      <div id="filePathContainer" class="file-path-container" style="display: none;">
+        <span class="file-path-icon">\uD83D\uDCC4</span>
+        <span id="markdownPath"></span>
+      </div>
+
+      <div id="questions"></div>
+      
+       <button class="primary" id="submitButton" disabled>Submit Answers <span class="submit-shortcut">\u2318\u21B5</span></button>
+      
+      <div class="footer" id="submitStatus"></div>
+    </div>
+    
+    <div class="loading-overlay" id="loadingOverlay">
+      <div class="status-text" id="loadingText">Processing...</div>
+    </div>
+
+    <script>
+      const interviewId = ${JSON.stringify(interviewId)};
+      const state = { data: null, answers: {}, activeQuestionIndex: 0, lastSig: null, customMode: {} };
+
+      function updateSubmitButton() {
+        const button = document.getElementById('submitButton');
+        if (!state.data) {
+          button.disabled = true;
+          return;
+        }
+
+        const questions = state.data.questions || [];
+        const allAnswered = questions.every((question) =>
+          (state.answers[question.id] || '').trim().length > 0,
+        );
+        button.disabled = state.data.isBusy || !questions.length || !allAnswered;
+        
+        const overlay = document.getElementById('loadingOverlay');
+        const overlayText = document.getElementById('loadingText');
+        if (state.data.isBusy) {
+          overlay.classList.add('active');
+          overlayText.textContent = "Agent Thinking...";
+        } else {
+          overlay.classList.remove('active');
+        }
+      }
+
+      function getOptionButtonId(questionId, index) {
+        return 'opt-' + questionId + '-' + index;
+      }
+
+      function createOption(question, option, index, isCustom) {
+        const button = document.createElement('button');
+        button.type = 'button';
+        button.className = 'option';
+        button.id = getOptionButtonId(question.id, index);
+        
+        const shortcut = index < 9 ? (index + 1) : '';
+        if (shortcut) {
+          const kbd = document.createElement('span');
+          kbd.className = 'shortcut';
+          kbd.textContent = shortcut;
+          button.appendChild(kbd);
+        }
+        
+        const text = document.createElement('span');
+        text.className = 'option-text';
+        text.textContent = isCustom ? 'Custom' : option;
+        button.appendChild(text);
+
+        // Visual marking for suggested/recommended answers
+        if (!isCustom && question.suggested === option) {
+          const badge = document.createElement('span');
+          badge.className = 'recommended-badge';
+          badge.textContent = 'Recommended';
+          button.appendChild(badge);
+        }
+
+        button.addEventListener('click', () => {
+          const questions = state.data?.questions || [];
+          const qIdx = questions.findIndex(q => q.id === question.id);
+          if (qIdx !== -1) {
+             state.activeQuestionIndex = qIdx;
+             updateActiveQuestionFocus();
+          }
+          handleOptionSelect(question, option, isCustom);
+        });
+        
+        return button;
+      }
+
+      function handleOptionSelect(question, option, isCustom) {
+        const textarea = document.getElementById('answer-' + question.id);
+        
+        if (isCustom) {
+          state.customMode[question.id] = true;
+          state.answers[question.id] = state.customMode[question.id]
+            ? state.answers[question.id] || ''
+            : '';
+          updateTextareaVisibility(question.id);
+          updateOptionsDOM(question.id);
+          if (textarea) {
+            textarea.focus();
+          }
+        } else {
+          state.customMode[question.id] = false;
+          state.answers[question.id] = option;
+          updateTextareaVisibility(question.id);
+          advanceToNextQuestion(question.id);
+        }
+        
+        updateSubmitButton();
+        updateOptionsDOM(question.id);
+      }
+
+      function updateTextareaVisibility(questionId) {
+        const textarea = document.getElementById('answer-' + questionId);
+        if (!textarea) return;
+        if (state.customMode[questionId]) {
+          textarea.classList.remove('hidden-textarea');
+        } else {
+          textarea.classList.add('hidden-textarea');
+        }
+      }
+
+      function advanceToNextQuestion(currentQuestionId) {
+        const questions = state.data?.questions || [];
+        const currentIndex = questions.findIndex(q => q.id === currentQuestionId);
+        
+        if (currentIndex >= 0 && currentIndex < questions.length - 1) {
+          state.activeQuestionIndex = currentIndex + 1;
+          updateActiveQuestionFocus();
+          const nextQuestion = questions[currentIndex + 1];
+          const nextEl = document.getElementById('question-' + nextQuestion.id);
+          if (nextEl) {
+            nextEl.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          }
+        } else if (currentIndex === questions.length - 1) {
+          const submitBtn = document.getElementById('submitButton');
+          if (submitBtn && !submitBtn.disabled) {
+            submitBtn.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          }
+        }
+      }
+
+      function updateOptionsDOM(questionId) {
+        const question = (state.data?.questions || []).find(q => q.id === questionId);
+        if (!question) return;
+        
+        const predefined = question.options || [];
+        const currentAnswer = state.answers[question.id];
+        
+        predefined.forEach((opt, idx) => {
+           const btn = document.getElementById(getOptionButtonId(questionId, idx));
+           if (btn) {
+              if (currentAnswer === opt) btn.classList.add('selected');
+              else btn.classList.remove('selected');
+           }
+        });
+        
+        const customBtn = document.getElementById(getOptionButtonId(questionId, predefined.length));
+        if (customBtn) {
+           if (state.customMode[questionId]) {
+               customBtn.classList.add('selected');
+            } else {
+               customBtn.classList.remove('selected');
+           }
+        }
+      }
+
+      function updateActiveQuestionFocus() {
+         const questions = state.data?.questions || [];
+         questions.forEach((q, idx) => {
+            const wrapper = document.getElementById('question-' + q.id);
+            if (wrapper) {
+               if (idx === state.activeQuestionIndex) {
+                  wrapper.classList.add('active-question');
+               } else {
+                  wrapper.classList.remove('active-question');
+               }
+            }
+         });
+      }
+
+      document.addEventListener('keydown', (e) => {
+        const isSubmitShortcut =
+          (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) ||
+          (e.key === 's' && (e.metaKey || e.ctrlKey));
+        if (isSubmitShortcut) {
+          const submitBtn = document.getElementById('submitButton');
+          if (submitBtn && !submitBtn.disabled) {
+            submitBtn.click();
+            e.preventDefault();
+          }
+          return;
+        }
+
+        if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') return;
+        if (e.ctrlKey || e.metaKey || e.altKey) return;
+
+        const questions = state.data?.questions || [];
+        if (!questions.length) return;
+
+         const num = parseInt(e.key, 10);
+         if (num >= 1 && num <= 9) {
+          const activeQ = questions[state.activeQuestionIndex];
+          if (!activeQ) return;
+          
+          const options = activeQ.options || [];
+          if (!options.length) return;
+
+          const idx = num - 1;
+          
+          if (idx < options.length) {
+            handleOptionSelect(activeQ, options[idx], false);
+            e.preventDefault();
+          } else if (idx === options.length) {
+            handleOptionSelect(activeQ, 'Custom', true);
+            e.preventDefault();
+         }
+
+        }
+        
+        if (e.key === 'ArrowDown') {
+           if (state.activeQuestionIndex < questions.length - 1) {
+              state.activeQuestionIndex++;
+              updateActiveQuestionFocus();
+              const wrapper = document.getElementById('question-' + questions[state.activeQuestionIndex].id);
+              if (wrapper) wrapper.scrollIntoView({ behavior: 'smooth', block: 'center' });
+              e.preventDefault();
+           }
+        }
+        if (e.key === 'ArrowUp') {
+           if (state.activeQuestionIndex > 0) {
+              state.activeQuestionIndex--;
+              updateActiveQuestionFocus();
+              const wrapper = document.getElementById('question-' + questions[state.activeQuestionIndex].id);
+              if (wrapper) wrapper.scrollIntoView({ behavior: 'smooth', block: 'center' });
+              e.preventDefault();
+           }
+        }
+      });
+
+      function renderQuestions(questions) {
+        const sig = JSON.stringify(questions);
+        const container = document.getElementById('questions');
+
+        if (state.lastSig === sig) {
+          questions.forEach((q) => updateOptionsDOM(q.id));
+          updateActiveQuestionFocus();
+          return;
+        }
+        
+        state.lastSig = sig;
+        container.replaceChildren();
+
+        if (!questions.length && !state.data?.isBusy) {
+          const empty = document.createElement('p');
+          empty.className = 'muted';
+          empty.style.textAlign = 'center';
+          empty.style.padding = '48px 0';
+          empty.textContent = 'No active questions right now.';
+          container.appendChild(empty);
+          return;
+        }
+
+        questions.forEach((question, idx) => {
+          const wrapper = document.createElement('div');
+          wrapper.className = 'question';
+          wrapper.id = 'question-' + question.id;
+          
+           if (question.suggested && !state.answers[question.id]) {
+             state.answers[question.id] = question.suggested;
+             state.customMode[question.id] = false;
+            }
+
+          const title = document.createElement('h3');
+          title.textContent = question.question;
+          wrapper.appendChild(title);
+
+          const predefined = question.options || [];
+          if (predefined.length) {
+            const options = document.createElement('div');
+            options.className = 'options';
+            predefined.forEach((option, optIdx) => {
+              options.appendChild(createOption(question, option, optIdx, false));
+            });
+            options.appendChild(createOption(question, 'Custom', predefined.length, true));
+            wrapper.appendChild(options);
+          }
+
+           const textarea = document.createElement('textarea');
+           textarea.id = 'answer-' + question.id;
+           textarea.placeholder = 'Type your answer here...';
+           textarea.value = state.customMode[question.id] ? (state.answers[question.id] || '') : '';
+           if (!state.customMode[question.id]) {
+             textarea.classList.add('hidden-textarea');
+           }
+           
+           textarea.addEventListener('focus', () => {
+              state.activeQuestionIndex = idx;
+            updateActiveQuestionFocus();
+          });
+          
+          textarea.addEventListener('input', () => {
+            state.answers[question.id] = textarea.value;
+            updateSubmitButton();
+            updateOptionsDOM(question.id);
+          });
+          wrapper.appendChild(textarea);
+
+          container.appendChild(wrapper);
+        });
+        
+        updateActiveQuestionFocus();
+        questions.forEach(q => updateOptionsDOM(q.id));
+      }
+
+      function render(data) {
+        state.data = data;
+        document.getElementById('idea').textContent = data.interview.idea || 'Interview';
+        document.getElementById('summary').textContent = data.summary || 'Session in progress.';
+        document.getElementById('status').textContent = data.mode.toUpperCase();
+        
+        // Render Markdown Path
+        const pathContainer = document.getElementById('filePathContainer');
+        const pathElement = document.getElementById('markdownPath');
+        const mdPath = data.markdownPath || (data.interview && data.interview.markdownPath);
+        if (mdPath) {
+          pathElement.textContent = mdPath;
+          pathContainer.style.display = 'flex';
+        } else {
+          pathContainer.style.display = 'none';
+        }
+        
+        renderQuestions(data.questions || []);
+        updateSubmitButton();
+      }
+
+      async function refresh() {
+        const response = await fetch('/api/interviews/' + encodeURIComponent(interviewId) + '/state');
+        const data = await response.json();
+        if (!response.ok) throw new Error(data.error || 'Failed to load state');
+        render(data);
+      }
+
+      document.getElementById('submitButton').addEventListener('click', async () => {
+        if (!state.data) return;
+        const answers = (state.data.questions || []).map((question) => {
+          return {
+            questionId: question.id,
+            answer: (state.answers[question.id] || '').trim(),
+          };
+        });
+
+        const overlay = document.getElementById('loadingOverlay');
+        const overlayText = document.getElementById('loadingText');
+        overlay.classList.add('active');
+        overlayText.textContent = "Submitting Answers...";
+
+        try {
+          const response = await fetch('/api/interviews/' + encodeURIComponent(interviewId) + '/answers', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ answers }),
+          });
+          const payload = await response.json();
+          document.getElementById('submitStatus').textContent = payload.message || (response.ok ? 'Answers submitted successfully.' : 'Submission failed.');
+        } catch (err) {
+          document.getElementById('submitStatus').textContent = 'Error submitting answers.';
+        }
+        try {
+          await refresh();
+        } catch (_error) {
+          overlay.classList.remove('active');
+        }
+      });
+
+      refresh().catch((error) => {
+        document.getElementById('submitStatus').textContent = error.message || 'Failed to load interview.';
+      });
+      setInterval(() => {
+        refresh().catch(() => {});
+      }, 2500);
+    </script>
+  </body>
+</html>`;
+}
+
+// src/interview/server.ts
+function getSubmissionStatus(error) {
+  if (error instanceof SyntaxError) {
+    return 400;
+  }
+  const message = error instanceof Error ? error.message : "";
+  if (message === "Interview not found") {
+    return 404;
+  }
+  if (message.includes("busy")) {
+    return 409;
+  }
+  if (message.includes("waiting for a valid agent update") || message.includes("There are no active interview questions") || message.includes("Answer every active interview question") || message.includes("Answers do not match") || message.includes("Request body too large") || message.includes("Invalid answers payload") || message.includes("no longer active")) {
+    return 400;
+  }
+  return 500;
+}
+function parseAnswersPayload(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Invalid answers payload.");
+  }
+  const answersRaw = value.answers;
+  if (!Array.isArray(answersRaw)) {
+    throw new Error("Invalid answers payload.");
+  }
+  return {
+    answers: answersRaw.map((answer) => {
+      if (!answer || typeof answer !== "object") {
+        throw new Error("Invalid answers payload.");
+      }
+      const record = answer;
+      if (typeof record.questionId !== "string" || typeof record.answer !== "string") {
+        throw new Error("Invalid answers payload.");
+      }
+      return {
+        questionId: record.questionId.trim(),
+        answer: record.answer.trim()
+      };
+    })
+  };
+}
+async function readJsonBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > 64 * 1024) {
+      throw new Error("Request body too large");
+    }
+    chunks.push(buffer);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  return raw ? JSON.parse(raw) : {};
+}
+function sendJson(response, status, value) {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json; charset=utf-8");
+  response.end(`${JSON.stringify(value)}
+`);
+}
+function sendHtml(response, html) {
+  response.statusCode = 200;
+  response.setHeader("content-type", "text/html; charset=utf-8");
+  response.end(html);
+}
+function createInterviewServer(deps) {
+  let baseUrl = null;
+  let startPromise = null;
+  async function handle(request, response) {
+    const url = new URL2(request.url ?? "/", "http://127.0.0.1");
+    const pathname = url.pathname;
+    if (request.method === "GET" && pathname.startsWith("/interview/")) {
+      sendHtml(response, renderInterviewPage(pathname.split("/").pop() ?? "unknown"));
+      return;
+    }
+    const stateMatch = pathname.match(/^\/api\/interviews\/([^/]+)\/state$/);
+    if (request.method === "GET" && stateMatch) {
+      try {
+        const state = await deps.getState(stateMatch[1]);
+        sendJson(response, 200, state);
+      } catch (error) {
+        sendJson(response, 404, {
+          error: error instanceof Error ? error.message : "Interview not found"
+        });
+      }
+      return;
+    }
+    const answersMatch = pathname.match(/^\/api\/interviews\/([^/]+)\/answers$/);
+    if (request.method === "POST" && answersMatch) {
+      try {
+        const body = parseAnswersPayload(await readJsonBody(request));
+        await deps.submitAnswers(answersMatch[1], body.answers);
+        sendJson(response, 200, {
+          ok: true,
+          message: "Answers submitted to the OpenCode session."
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to submit answers.";
+        const status = getSubmissionStatus(error);
+        sendJson(response, status, {
+          ok: false,
+          message
+        });
+      }
+      return;
+    }
+    sendJson(response, 404, { error: "Not found" });
+  }
+  async function ensureStarted() {
+    if (baseUrl) {
+      return baseUrl;
+    }
+    if (startPromise) {
+      return startPromise;
+    }
+    startPromise = new Promise((resolve, reject) => {
+      const server = createServer((request, response) => {
+        handle(request, response).catch((error) => {
+          sendJson(response, 500, {
+            error: error instanceof Error ? error.message : "Internal server error"
+          });
+        });
+      });
+      server.on("error", (error) => {
+        startPromise = null;
+        reject(error);
+      });
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          startPromise = null;
+          reject(new Error("Failed to start interview server"));
+          return;
+        }
+        baseUrl = `http://127.0.0.1:${address.port}`;
+        resolve(baseUrl);
+      });
+    });
+    return startPromise;
+  }
+  return {
+    ensureStarted
+  };
+}
+
+// src/interview/service.ts
+import { spawn as spawn4 } from "child_process";
+import * as fsSync from "fs";
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
+
+// src/interview/parser.ts
+var INTERVIEW_BLOCK_REGEX = /<interview_state>\s*([\s\S]*?)\s*<\/interview_state>/i;
+function normalizeQuestion(value, index) {
+  const question = typeof value.question === "string" ? value.question.trim() : "";
+  if (!question) {
+    return null;
+  }
+  const options = Array.isArray(value.options) ? value.options.filter((option) => typeof option === "string").map((option) => option.trim()).filter(Boolean).slice(0, 4) : [];
+  return {
+    id: typeof value.id === "string" && value.id.trim().length > 0 ? value.id.trim() : `q-${index + 1}`,
+    question,
+    options,
+    suggested: typeof value.suggested === "string" && value.suggested.trim().length > 0 ? value.suggested.trim() : undefined
+  };
+}
+function flattenMessage(message) {
+  return (message.parts ?? []).map((part) => part.text ?? "").join(`
+`).trim();
+}
+function buildFallbackState(messages) {
+  const answerCount = messages.filter((message) => message.info?.role === "user").length;
+  return {
+    summary: answerCount > 0 ? "Interview in progress." : "Waiting for the first interview response.",
+    questions: []
+  };
+}
+function parseAssistantState(text, maxQuestions = 2) {
+  const match = text.match(INTERVIEW_BLOCK_REGEX);
+  if (!match) {
+    return { state: null };
+  }
+  try {
+    const parsed = JSON.parse(match[1]);
+    const summary = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+    const title = typeof parsed.title === "string" && parsed.title.trim().length > 0 ? parsed.title.trim() : undefined;
+    const questions = Array.isArray(parsed.questions) ? parsed.questions.filter((value) => typeof value === "object" && value !== null).map((value, index) => normalizeQuestion(value, index)).filter((value) => value !== null).slice(0, maxQuestions) : [];
+    return {
+      state: {
+        summary,
+        title,
+        questions
+      }
+    };
+  } catch (error) {
+    return {
+      state: null,
+      error: error instanceof Error ? error.message : "Failed to parse interview state"
+    };
+  }
+}
+function findLatestAssistantState(messages, maxQuestions = 2) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info?.role !== "assistant") {
+      continue;
+    }
+    const parsed = parseAssistantState(flattenMessage(message), maxQuestions);
+    if (parsed.state) {
+      return {
+        state: parsed.state
+      };
+    }
+    return {
+      state: null,
+      latestAssistantError: parsed.error ?? "Missing <interview_state> block"
+    };
+  }
+  return {
+    state: null
+  };
+}
+
+// src/interview/prompts.ts
+function formatQuestionContext(questions) {
+  if (questions.length === 0) {
+    return "No current interview questions were parsed.";
+  }
+  return questions.map((question, index) => {
+    const options = question.options.length ? `Options: ${question.options.join(" | ")}` : "Options: freeform";
+    const suggested = question.suggested ? `Suggested: ${question.suggested}` : "Suggested: none";
+    return `${index + 1}. ${question.question}
+${options}
+${suggested}`;
+  }).join(`
+
+`);
+}
+function buildKickoffPrompt(idea, maxQuestions) {
+  return [
+    "You are running an interview q&a session for the user inside their repository.",
+    `Initial idea: ${idea}`,
+    `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",',
+    '  "title": "concise-kebab-case-title-for-filename",',
+    '  "questions": [',
+    "    {",
+    '      "id": "short-kebab-id-2",',
+    '      "question": "question text",',
+    '      "options": ["option 1", "option 2", "option 3"],',
+    '      "suggested": "best suggested option"',
+    "    }",
+    "  ]",
+    "}",
+    "</interview_state>",
+    "Rules:",
+    `- Return 0 to ${maxQuestions} questions.`,
+    "- If there are no more useful questions, 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(`
+`);
+}
+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.",
+    "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.",
+    "Return the same <interview_state> JSON block format as before."
+  ].join(`
+`);
+}
+function buildAnswerPrompt(answers, questions, maxQuestions) {
+  const answerText = answers.map((answer, index) => `${index + 1}. ${answer.questionId}: ${answer.answer.trim()}`).join(`
+`);
+  return [
+    "Continue the same interview.",
+    "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.`,
+    "Return the same <interview_state> JSON block format as before."
+  ].join(`
+
+`);
+}
+
+// src/interview/service.ts
+var COMMAND_NAME2 = "interview";
+var DEFAULT_MAX_QUESTIONS = 2;
+var DEFAULT_OUTPUT_FOLDER = "interview";
+var DEFAULT_AUTO_OPEN_BROWSER = true;
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  try {
+    const child = spawn4(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", (error) => {
+      log("[interview] failed to open browser:", { error: error.message, url });
+    });
+    child.unref();
+  } catch (error) {
+    log("[interview] failed to spawn browser opener:", {
+      error: error instanceof Error ? error.message : String(error),
+      url
+    });
+  }
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function normalizeOutputFolder(outputFolder) {
+  const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
+  return normalized || DEFAULT_OUTPUT_FOLDER;
+}
+function createInterviewDirectoryPath(directory, outputFolder) {
+  return path6.join(directory, normalizeOutputFolder(outputFolder));
+}
+function createInterviewFilePath(directory, outputFolder, idea) {
+  const fileName = `${slugify(idea) || "interview"}.md`;
+  return path6.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+}
+function relativeInterviewPath(directory, filePath) {
+  return path6.relative(directory, filePath) || path6.basename(filePath);
+}
+function extractHistorySection(document) {
+  const marker = `## Q&A history
+
+`;
+  const index = document.indexOf(marker);
+  return index >= 0 ? document.slice(index + marker.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();
+}
+function extractTitle(document) {
+  const match = document.match(/^#\s+(.+)$/m);
+  return match?.[1]?.trim() ?? "";
+}
+function buildInterviewDocument(idea, summary, history) {
+  const normalizedSummary = summary.trim() || "Waiting for interview answers.";
+  const normalizedHistory = history.trim() || "No answers yet.";
+  return [
+    `# ${idea}`,
+    "",
+    "## Current spec",
+    "",
+    normalizedSummary,
+    "",
+    "## Q&A history",
+    "",
+    normalizedHistory,
+    ""
+  ].join(`
+`);
+}
+async function ensureInterviewFile(record) {
+  await fs5.mkdir(path6.dirname(record.markdownPath), { recursive: true });
+  try {
+    await fs5.access(record.markdownPath);
+  } catch {
+    await fs5.writeFile(record.markdownPath, buildInterviewDocument(record.idea, "", ""), "utf8");
+  }
+}
+async function readInterviewDocument(record) {
+  await ensureInterviewFile(record);
+  return fs5.readFile(record.markdownPath, "utf8");
+}
+async function rewriteInterviewDocument(record, summary) {
+  const existing = await readInterviewDocument(record);
+  const history = extractHistorySection(existing);
+  const next = buildInterviewDocument(record.idea, summary, history);
+  await fs5.writeFile(record.markdownPath, next, "utf8");
+  return next;
+}
+async function appendInterviewAnswers(record, questions, answers) {
+  const existing = await readInterviewDocument(record);
+  const summary = extractSummarySection(existing);
+  const history = extractHistorySection(existing);
+  const questionMap = new Map(questions.map((question) => [question.id, question]));
+  const appended = answers.map((answer) => {
+    const question = questionMap.get(answer.questionId);
+    return question ? `Q: ${question.question}
+A: ${answer.answer.trim()}` : null;
+  }).filter((value) => value !== null).join(`
+
+`);
+  const nextHistory = [history === "No answers yet." ? "" : history, appended].filter(Boolean).join(`
+
+`);
+  await fs5.writeFile(record.markdownPath, buildInterviewDocument(record.idea, summary, nextHistory), "utf8");
+}
+function resolveExistingInterviewPath(directory, outputFolder, value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const outputDir = createInterviewDirectoryPath(directory, outputFolder);
+  const candidates = new Set;
+  if (path6.isAbsolute(trimmed)) {
+    candidates.add(trimmed);
+  } else {
+    candidates.add(path6.resolve(directory, trimmed));
+    candidates.add(path6.join(outputDir, trimmed));
+    if (!trimmed.endsWith(".md")) {
+      candidates.add(path6.join(outputDir, `${trimmed}.md`));
+    }
+  }
+  for (const candidate of candidates) {
+    if (path6.extname(candidate) !== ".md") {
+      continue;
+    }
+    if (fsSync.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function createInterviewService(ctx, config, deps) {
+  const maxQuestions = config?.maxQuestions ?? DEFAULT_MAX_QUESTIONS;
+  const outputFolder = normalizeOutputFolder(config?.outputFolder ?? DEFAULT_OUTPUT_FOLDER);
+  const autoOpenBrowser = config?.autoOpenBrowser ?? DEFAULT_AUTO_OPEN_BROWSER;
+  const browserOpener = deps?.openBrowser ?? openBrowser;
+  const activeInterviewIds = new Map;
+  const interviewsById = new Map;
+  const sessionBusy = new Map;
+  const browserOpened = new Set;
+  let resolveBaseUrl = null;
+  function setBaseUrlResolver(resolver) {
+    resolveBaseUrl = resolver;
+  }
+  async function ensureServer() {
+    if (!resolveBaseUrl) {
+      throw new Error("Interview server is not attached");
+    }
+    return resolveBaseUrl();
+  }
+  function maybeOpenBrowser(interviewId, url) {
+    if (!autoOpenBrowser) {
+      return;
+    }
+    if (browserOpened.has(interviewId)) {
+      return;
+    }
+    browserOpened.add(interviewId);
+    browserOpener(url);
+  }
+  async function maybeRenameWithTitle(interview, assistantTitle) {
+    if (!assistantTitle) {
+      return;
+    }
+    const newSlug = slugify(assistantTitle);
+    if (!newSlug) {
+      return;
+    }
+    const currentFileName = path6.basename(interview.markdownPath, ".md");
+    if (currentFileName === newSlug) {
+      return;
+    }
+    const dir = path6.dirname(interview.markdownPath);
+    const newPath = path6.join(dir, `${newSlug}.md`);
+    try {
+      await fs5.access(newPath);
+      return;
+    } catch {}
+    try {
+      await fs5.rename(interview.markdownPath, newPath);
+      interview.markdownPath = newPath;
+      log("[interview] renamed file with assistant title:", {
+        from: currentFileName,
+        to: newSlug
+      });
+    } catch (error) {
+      log("[interview] failed to rename file:", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async function loadMessages(sessionID) {
+    const result = await ctx.client.session.messages({
+      path: { id: sessionID }
+    });
+    return result.data;
+  }
+  function isUserVisibleMessage(message) {
+    return !(message.parts ?? []).some((part) => hasInternalInitiatorMarker(part));
+  }
+  function getInterviewById(interviewId) {
+    return interviewsById.get(interviewId) ?? null;
+  }
+  async function createInterview(sessionID, idea) {
+    const normalizedIdea = idea.trim();
+    const activeId = activeInterviewIds.get(sessionID);
+    if (activeId) {
+      const active = interviewsById.get(activeId);
+      if (active && active.status === "active") {
+        if (active.idea === normalizedIdea) {
+          return active;
+        }
+        active.status = "abandoned";
+      }
+    }
+    const messages = await loadMessages(sessionID);
+    const record = {
+      id: `${Date.now()}-${slugify(idea) || "interview"}`,
+      sessionID,
+      idea: normalizedIdea,
+      markdownPath: createInterviewFilePath(ctx.directory, outputFolder, idea),
+      createdAt: nowIso(),
+      status: "active",
+      baseMessageCount: messages.length
+    };
+    await ensureInterviewFile(record);
+    activeInterviewIds.set(sessionID, record.id);
+    interviewsById.set(record.id, record);
+    return record;
+  }
+  async function resumeInterview(sessionID, markdownPath) {
+    const activeId = activeInterviewIds.get(sessionID);
+    if (activeId) {
+      const active = interviewsById.get(activeId);
+      if (active && active.status === "active") {
+        if (active.markdownPath === markdownPath) {
+          return active;
+        }
+        active.status = "abandoned";
+      }
+    }
+    const document = await fs5.readFile(markdownPath, "utf8");
+    const messages = await loadMessages(sessionID);
+    const title = extractTitle(document);
+    const record = {
+      id: `${Date.now()}-${slugify(path6.basename(markdownPath, ".md")) || "interview"}`,
+      sessionID,
+      idea: title || path6.basename(markdownPath, ".md"),
+      markdownPath,
+      createdAt: nowIso(),
+      status: "active",
+      baseMessageCount: messages.length
+    };
+    activeInterviewIds.set(sessionID, record.id);
+    interviewsById.set(record.id, record);
+    return record;
+  }
+  async function syncInterview(interview) {
+    const allMessages = await loadMessages(interview.sessionID);
+    const interviewMessages = allMessages.slice(interview.baseMessageCount).filter(isUserVisibleMessage);
+    const parsed = findLatestAssistantState(interviewMessages, maxQuestions);
+    const existingDocument = await readInterviewDocument(interview);
+    const fallbackState = buildFallbackState(interviewMessages);
+    const state = parsed.state ?? {
+      ...fallbackState,
+      summary: extractSummarySection(existingDocument) || fallbackState.summary
+    };
+    await maybeRenameWithTitle(interview, state.title);
+    const document = await rewriteInterviewDocument(interview, state.summary);
+    return {
+      interview,
+      url: `${await ensureServer()}/interview/${interview.id}`,
+      markdownPath: relativeInterviewPath(ctx.directory, interview.markdownPath),
+      mode: interview.status === "abandoned" ? "abandoned" : parsed.latestAssistantError ? "error" : sessionBusy.get(interview.sessionID) === true ? "awaiting-agent" : state.questions.length > 0 ? "awaiting-user" : "awaiting-agent",
+      lastParseError: parsed.latestAssistantError,
+      isBusy: sessionBusy.get(interview.sessionID) === true,
+      summary: state.summary,
+      questions: state.questions,
+      document
+    };
+  }
+  async function notifyInterviewUrl(sessionID, interview) {
+    const baseUrl = await ensureServer();
+    const url = `${baseUrl}/interview/${interview.id}`;
+    maybeOpenBrowser(interview.id, url);
+    await ctx.client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        noReply: true,
+        parts: [
+          {
+            type: "text",
+            text: [
+              "\u2394 Interview UI ready",
+              "",
+              `Open: ${url}`,
+              `Document: ${relativeInterviewPath(ctx.directory, interview.markdownPath)}`,
+              "",
+              "[system status: continue without acknowledging this notification]"
+            ].join(`
+`)
+          }
+        ]
       }
-      if (lastAssistantIsQuestion) {
-        log(`[${HOOK_NAME}] Skipped: last message is question`, {
-          sessionID
-        });
-        return;
+    });
+  }
+  function registerCommand(opencodeConfig) {
+    const configCommand = opencodeConfig.command;
+    if (!configCommand?.[COMMAND_NAME2]) {
+      if (!opencodeConfig.command) {
+        opencodeConfig.command = {};
       }
-      if (state.consecutiveContinuations >= maxContinuations) {
-        log(`[${HOOK_NAME}] Skipped: max continuations reached`, {
-          sessionID,
-          consecutive: state.consecutiveContinuations,
-          max: maxContinuations
-        });
-        return;
+      opencodeConfig.command[COMMAND_NAME2] = {
+        template: "Start an interview and write a live markdown spec",
+        description: "Open a localhost interview UI linked to the current OpenCode session"
+      };
+    }
+  }
+  async function getInterviewState(interviewId) {
+    const interview = getInterviewById(interviewId);
+    if (!interview) {
+      throw new Error("Interview not found");
+    }
+    return syncInterview(interview);
+  }
+  async function submitAnswers(interviewId, answers) {
+    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 now = Date.now();
-      if (now < state.suppressUntil) {
-        log(`[${HOOK_NAME}] Skipped: in suppress window`, {
-          sessionID,
-          suppressUntil: state.suppressUntil
-        });
-        return;
+      const activeQuestionIds = new Set(state.questions.map((question) => question.id));
+      if (activeQuestionIds.size === 0) {
+        throw new Error("There are no active interview questions to answer.");
       }
-      if (state.pendingTimer !== null || state.isAutoInjecting) {
-        log(`[${HOOK_NAME}] Skipped: timer pending or injection in flight`, {
-          sessionID
-        });
-        return;
+      if (answers.length !== activeQuestionIds.size) {
+        throw new Error("Answer every active interview question before submitting.");
       }
-      log(`[${HOOK_NAME}] Scheduling continuation`, {
-        sessionID,
-        delayMs: cooldownMs
-      });
-      ctx.client.session.prompt({
-        path: { id: sessionID },
+      const invalidAnswer = answers.find((answer) => !activeQuestionIds.has(answer.questionId) || !answer.answer.trim());
+      if (invalidAnswer) {
+        throw new Error("Answers do not match the current interview questions.");
+      }
+      await appendInterviewAnswers(interview, state.questions, answers);
+      const prompt = buildAnswerPrompt(answers, state.questions, maxQuestions);
+      await ctx.client.session.prompt({
+        path: { id: interview.sessionID },
         body: {
-          noReply: true,
-          parts: [
-            {
-              type: "text",
-              text: [
-                `\u2394 Auto-continue: ${incompleteCount} incomplete todos remaining \u2014 resuming in ${cooldownMs / 1000}s \u2014 Esc\xD72 to cancel`,
-                "",
-                "[system status: continue without acknowledging this notification]"
-              ].join(`
-`)
-            }
-          ]
-        }
-      }).catch(() => {});
-      state.pendingTimer = setTimeout(async () => {
-        state.pendingTimer = null;
-        if (!state.enabled) {
-          log(`[${HOOK_NAME}] Cancelled: disabled during cooldown`, {
-            sessionID
-          });
-          return;
-        }
-        state.isAutoInjecting = true;
-        try {
-          await ctx.client.session.prompt({
-            path: { id: sessionID },
-            body: {
-              parts: [createInternalAgentTextPart(CONTINUATION_PROMPT)]
-            }
-          });
-          state.consecutiveContinuations++;
-          log(`[${HOOK_NAME}] Continuation injected`, {
-            sessionID,
-            consecutive: state.consecutiveContinuations
-          });
-        } catch (error) {
-          log(`[${HOOK_NAME}] Error: failed to inject continuation`, {
-            sessionID,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        } finally {
-          state.isAutoInjecting = false;
-        }
-      }, cooldownMs);
-    } else if (event.type === "session.status") {
-      const status = properties.status;
-      const sessionID = properties.sessionID;
-      if (status?.type === "busy") {
-        const isOrchestrator = sessionID === state.orchestratorSessionId;
-        if (isOrchestrator) {
-          cancelPendingTimer(state);
-        }
-        if (!state.isAutoInjecting && isOrchestrator && state.consecutiveContinuations > 0) {
-          state.consecutiveContinuations = 0;
-          log(`[${HOOK_NAME}] Reset consecutive count on user activity`, {
-            sessionID
-          });
+          parts: [createInternalAgentTextPart(prompt)]
         }
-      }
-    } else if (event.type === "session.error") {
-      const error = properties.error;
-      const sessionID = properties.sessionID;
-      const errorName = error?.name;
-      const isOrchestrator = sessionID === state.orchestratorSessionId;
-      if (isOrchestrator && (errorName === "MessageAbortedError" || errorName === "AbortError")) {
-        state.suppressUntil = Date.now() + SUPPRESS_AFTER_ABORT_MS;
-        log(`[${HOOK_NAME}] Suppressed continuation after abort`, {
-          sessionID,
-          errorName
-        });
-      }
-      if (isOrchestrator) {
-        cancelPendingTimer(state);
-        log(`[${HOOK_NAME}] Cancelled pending timer on error`, {
-          sessionID
-        });
-      }
-    } else if (event.type === "session.deleted") {
-      const deletedSessionId = properties.info?.id ?? properties.sessionID;
-      if (state.orchestratorSessionId === deletedSessionId) {
-        cancelPendingTimer(state);
-        log(`[${HOOK_NAME}] Cancelled pending timer on orchestrator delete`, {
-          sessionID: deletedSessionId
-        });
-        resetState(state);
-        state.orchestratorSessionId = null;
-        log(`[${HOOK_NAME}] Reset orchestrator session on delete`, {
-          sessionID: deletedSessionId
-        });
+      });
+      promptSent = true;
+    } finally {
+      if (!promptSent) {
+        sessionBusy.set(interview.sessionID, false);
       }
     }
   }
   async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME) {
+    if (input.command !== COMMAND_NAME2) {
       return;
     }
-    if (!state.orchestratorSessionId) {
-      state.orchestratorSessionId = input.sessionID;
-    }
+    const idea = input.arguments.trim();
     output.parts.length = 0;
-    const arg = input.arguments.trim().toLowerCase();
-    let newEnabled;
-    if (arg === "on") {
-      newEnabled = true;
-    } else if (arg === "off") {
-      newEnabled = false;
-    } else {
-      newEnabled = !state.enabled;
+    if (!idea) {
+      const activeId = activeInterviewIds.get(input.sessionID);
+      const interview2 = activeId ? interviewsById.get(activeId) : null;
+      if (!interview2 || interview2.status !== "active") {
+        output.parts.push(createInternalAgentTextPart("The user ran /interview without an idea. Ask them for the product idea in one sentence."));
+        return;
+      }
+      await notifyInterviewUrl(input.sessionID, interview2);
+      output.parts.push(createInternalAgentTextPart(`The interview UI was reopened for the current session. If your latest interview turn already contains unanswered questions, do not repeat them. Otherwise continue the interview with up to ${maxQuestions} clarifying questions and include the structured <interview_state> block.`));
+      return;
     }
-    state.enabled = newEnabled;
-    state.consecutiveContinuations = 0;
-    if (!newEnabled) {
-      cancelPendingTimer(state);
-      output.parts.push(createInternalAgentTextPart("[Auto-continue: disabled by user command.]"));
-      log(`[${HOOK_NAME}] Disabled via /${COMMAND_NAME} command`);
+    const resumePath = resolveExistingInterviewPath(ctx.directory, outputFolder, idea);
+    if (resumePath) {
+      const interview2 = await resumeInterview(input.sessionID, resumePath);
+      const document = await fs5.readFile(interview2.markdownPath, "utf8");
+      await notifyInterviewUrl(input.sessionID, interview2);
+      output.parts.push(createInternalAgentTextPart(buildResumePrompt(document, maxQuestions)));
       return;
     }
-    state.suppressUntil = 0;
-    log(`[${HOOK_NAME}] Enabled via /${COMMAND_NAME} command`, {
-      maxContinuations
-    });
-    let hasIncompleteTodos = false;
-    try {
-      const todosResult = await ctx.client.session.todo({
-        path: { id: input.sessionID }
-      });
-      const todos = todosResult.data;
-      hasIncompleteTodos = todos.some((t) => !TERMINAL_TODO_STATUSES.includes(t.status));
-    } catch (error) {
-      log(`[${HOOK_NAME}] Warning: failed to fetch todos in command hook`, {
-        sessionID: input.sessionID,
-        error: error instanceof Error ? error.message : String(error)
-      });
+    const interview = await createInterview(input.sessionID, idea);
+    await notifyInterviewUrl(input.sessionID, interview);
+    output.parts.push(createInternalAgentTextPart(buildKickoffPrompt(idea, maxQuestions)));
+  }
+  async function handleEvent(input) {
+    const { event } = input;
+    const properties = event.properties ?? {};
+    if (event.type === "session.status") {
+      const sessionID = properties.sessionID;
+      const status = properties.status;
+      if (sessionID) {
+        sessionBusy.set(sessionID, status?.type === "busy");
+      }
+      return;
     }
-    if (hasIncompleteTodos) {
-      output.parts.push(createInternalAgentTextPart(`${CONTINUATION_PROMPT} [Auto-continue enabled: up to ${maxContinuations} continuations.]`));
-    } else {
-      output.parts.push(createInternalAgentTextPart(`[Auto-continue: enabled for up to ${maxContinuations} continuations. No incomplete todos right now.]`));
+    if (event.type === "session.deleted") {
+      const deletedSessionId = (properties.info?.id ?? properties.sessionID) || null;
+      if (!deletedSessionId) {
+        return;
+      }
+      sessionBusy.delete(deletedSessionId);
+      const interviewId = activeInterviewIds.get(deletedSessionId);
+      if (!interviewId) {
+        return;
+      }
+      const interview = interviewsById.get(interviewId);
+      if (!interview) {
+        return;
+      }
+      interview.status = "abandoned";
+      activeInterviewIds.delete(deletedSessionId);
+      log("[interview] session deleted, interview marked abandoned", {
+        sessionID: deletedSessionId,
+        interviewId
+      });
     }
   }
   return {
-    tool: { auto_continue: autoContinue },
+    setBaseUrlResolver,
+    registerCommand,
+    handleCommandExecuteBefore,
     handleEvent,
-    handleCommandExecuteBefore
+    getInterviewState,
+    submitAnswers
+  };
+}
+
+// src/interview/manager.ts
+function createInterviewManager(ctx, config) {
+  const service = createInterviewService(ctx, config.interview);
+  const server = createInterviewServer({
+    getState: async (interviewId) => service.getInterviewState(interviewId),
+    submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers)
+  });
+  service.setBaseUrlResolver(() => server.ensureStarted());
+  return {
+    registerCommand: (config2) => service.registerCommand(config2),
+    handleCommandExecuteBefore: async (input, output) => service.handleCommandExecuteBefore(input, output),
+    handleEvent: async (input) => service.handleEvent(input)
   };
 }
 // src/mcp/context7.ts
@@ -4248,19 +5737,19 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
 import { tool as tool2 } from "@opencode-ai/plugin/tool";
 
 // src/tools/ast-grep/cli.ts
-import { existsSync as existsSync6 } from "fs";
-var {spawn: spawn4 } = globalThis.Bun;
+import { existsSync as existsSync7 } from "fs";
+var {spawn: spawn5 } = globalThis.Bun;
 
 // src/tools/ast-grep/constants.ts
-import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, statSync as statSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname5, join as join9 } from "path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2, unlinkSync } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var REPO = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
 function getAstGrepVersion() {
@@ -4284,19 +5773,19 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join7(homedir3(), "AppData", "Local");
-    return join7(base2, "oh-my-opencode-slim", "bin");
+    const base2 = localAppData || join8(homedir3(), "AppData", "Local");
+    return join8(base2, "oh-my-opencode-slim", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join7(homedir3(), ".cache");
-  return join7(base, "oh-my-opencode-slim", "bin");
+  const base = xdgCache || join8(homedir3(), ".cache");
+  return join8(base, "oh-my-opencode-slim", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join7(getCacheDir2(), getBinaryName());
-  return existsSync4(binaryPath) ? binaryPath : null;
+  const binaryPath = join8(getCacheDir2(), getBinaryName());
+  return existsSync5(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -4307,8 +5796,8 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath = join7(cacheDir, binaryName);
-  if (existsSync4(binaryPath)) {
+  const binaryPath = join8(cacheDir, binaryName);
+  if (existsSync5(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os3 } = platformInfo;
@@ -4316,21 +5805,21 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
-    if (!existsSync4(cacheDir)) {
+    if (!existsSync5(cacheDir)) {
       mkdirSync2(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join7(cacheDir, assetName);
+    const archivePath = join8(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync4(archivePath)) {
+    if (existsSync5(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync4(binaryPath)) {
+    if (process.platform !== "win32" && existsSync5(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     console.log(`[oh-my-opencode-slim] ast-grep binary ready.`);
@@ -4411,9 +5900,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname4(cliPkgPath);
-    const sgPath = join8(cliDir, binaryName);
-    if (existsSync5(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname5(cliPkgPath);
+    const sgPath = join9(cliDir, binaryName);
+    if (existsSync6(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -4422,19 +5911,19 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname4(pkgPath);
+      const pkgDir = dirname5(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join8(pkgDir, astGrepName);
-      if (existsSync5(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join9(pkgDir, astGrepName);
+      if (existsSync6(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path6 of homebrewPaths) {
-      if (existsSync5(path6) && isValidBinary(path6)) {
-        return path6;
+    for (const path7 of homebrewPaths) {
+      if (existsSync6(path7) && isValidBinary(path7)) {
+        return path7;
       }
     }
   }
@@ -4451,8 +5940,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path6) {
-  resolvedCliPath = path6;
+function setSgCliPath(path7) {
+  resolvedCliPath = path7;
 }
 var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -4462,7 +5951,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync6(currentPath)) {
+  if (currentPath !== "sg" && existsSync7(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -4470,7 +5959,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync6(syncPath)) {
+    if (syncPath && existsSync7(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -4509,14 +5998,14 @@ async function runSg(options) {
   const paths2 = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths2);
   let cliPath = getSgCliPath();
-  if (!existsSync6(cliPath) && cliPath !== "sg") {
+  if (!existsSync7(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS2;
-  const proc = spawn4([cliPath, ...args], {
+  const proc = spawn5([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -4971,10 +6460,10 @@ Returns the synthesized result with councillor summary.`,
 }
 // src/tools/lsp/client.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { extname, resolve as resolve3 } from "path";
+import { extname as extname2, resolve as resolve4 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
-var {spawn: spawn5 } = globalThis.Bun;
+var {spawn: spawn6 } = globalThis.Bun;
 import {
   createMessageConnection,
   StreamMessageReader,
@@ -4982,9 +6471,9 @@ import {
 } from "vscode-jsonrpc/node";
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join9, resolve as resolve2 } from "path";
+import { dirname as dirname7, join as join10, resolve as resolve3 } from "path";
 import whichSync from "which";
 
 // src/tools/lsp/config-store.ts
@@ -5015,8 +6504,8 @@ function hasUserLspConfig() {
 }
 
 // src/tools/lsp/constants.ts
-import { existsSync as existsSync7, readdirSync, statSync as statSync3 } from "fs";
-import { dirname as dirname5, resolve } from "path";
+import { existsSync as existsSync8, readdirSync, statSync as statSync3 } from "fs";
+import { dirname as dirname6, resolve as resolve2 } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -5033,13 +6522,13 @@ var LOCK_FILE_PATTERNS = [
   "yarn.lock"
 ];
 function* walkUpDirectories(start, stop) {
-  let dir = resolve(start);
+  let dir = resolve2(start);
   try {
     if (!statSync3(dir).isDirectory()) {
-      dir = dirname5(dir);
+      dir = dirname6(dir);
     }
   } catch {
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
@@ -5047,7 +6536,7 @@ function* walkUpDirectories(start, stop) {
     prevDir = dir;
     if (dir === stop)
       break;
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -5056,7 +6545,7 @@ function NearestRoot(includePatterns, excludePatterns) {
     if (excludePatterns) {
       for (const dir of walkUpDirectories(file, cwd)) {
         for (const pattern of excludePatterns) {
-          if (existsSync7(`${dir}/${pattern}`)) {
+          if (existsSync8(`${dir}/${pattern}`)) {
             return;
           }
         }
@@ -5072,7 +6561,7 @@ function NearestRoot(includePatterns, excludePatterns) {
               return dir;
             }
           } catch {}
-        } else if (existsSync7(`${dir}/${pattern}`)) {
+        } else if (existsSync8(`${dir}/${pattern}`)) {
           return dir;
         }
       }
@@ -5593,7 +7082,7 @@ function getServerWorkspace(config, filePath) {
     return;
   }
   if (!config.root) {
-    return dirname6(resolve2(filePath));
+    return dirname7(resolve3(filePath));
   }
   return config.root(filePath);
 }
@@ -5617,7 +7106,7 @@ function findInstalledServer(configs, filePath) {
   let firstNotInstalled = null;
   for (const config of configs) {
     const workspace = getServerWorkspace(config, filePath);
-    const resolvedCommand = resolveServerCommand(config.command, workspace ?? (filePath ? dirname6(resolve2(filePath)) : undefined));
+    const resolvedCommand = resolveServerCommand(config.command, workspace ?? (filePath ? dirname7(resolve3(filePath)) : undefined));
     const server = toResolvedServer(config, resolvedCommand ?? undefined);
     log(`[LSP] Considering server for ${config.extensions.join(", ")}: ${config.id} with command ${config.command.join(" ")}`);
     if (resolvedCommand) {
@@ -5660,11 +7149,11 @@ function resolveServerCommand(command, cwd) {
     return null;
   const [cmd, ...args] = command;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync8(cmd) ? command : null;
+    return existsSync9(cmd) ? command : null;
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const opencodeBin = join9(homedir4(), ".config", "opencode", "bin");
+  const opencodeBin = join10(homedir4(), ".config", "opencode", "bin");
   const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
   const result = whichSync.sync(cmd, {
     path: searchPath,
@@ -5675,11 +7164,11 @@ function resolveServerCommand(command, cwd) {
     return [result, ...args];
   }
   const localBinRoot = cwd ?? process.cwd();
-  const localBin = join9(localBinRoot, "node_modules", ".bin", cmd);
-  if (existsSync8(localBin)) {
+  const localBin = join10(localBinRoot, "node_modules", ".bin", cmd);
+  if (existsSync9(localBin)) {
     return [localBin, ...args];
   }
-  if (existsSync8(localBin + ext)) {
+  if (existsSync9(localBin + ext)) {
     return [localBin + ext, ...args];
   }
   return null;
@@ -5724,7 +7213,7 @@ function getDiagnosticsCapabilitySummary({
   };
 }
 function withTimeout(promise, ms, label, onTimeout) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) {
@@ -5740,7 +7229,7 @@ function withTimeout(promise, ms, label, onTimeout) {
       }
       settled = true;
       clearTimeout(timer);
-      resolve4(value);
+      resolve5(value);
     }, (error) => {
       if (settled) {
         return;
@@ -5944,7 +7433,7 @@ class LSPClient {
       command: command.join(" "),
       root: this.root
     });
-    this.proc = spawn5(command, {
+    this.proc = spawn6(command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -6030,7 +7519,7 @@ class LSPClient {
       this.processExited = true;
     });
     this.connection.listen();
-    await new Promise((resolve4) => setTimeout(resolve4, 100));
+    await new Promise((resolve5) => setTimeout(resolve5, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -6137,10 +7626,10 @@ stderr: ${stderr}` : ""));
     await this.ensureDocumentSynced(filePath);
   }
   async ensureDocumentSynced(filePath) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     const uri = pathToFileURL(absPath).href;
     const text = readFileSync4(absPath, "utf-8");
-    const ext = extname(absPath);
+    const ext = extname2(absPath);
     const languageId = getLanguageId(ext);
     const existing = this.documents.get(uri);
     if (!existing) {
@@ -6179,7 +7668,7 @@ stderr: ${stderr}` : ""));
     }
   }
   async definition(filePath, line, character) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.connection ? withTimeout(this.connection.sendRequest("textDocument/definition", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -6187,7 +7676,7 @@ stderr: ${stderr}` : ""));
     }), LSP_TIMEOUTS.request, `LSP definition (${this.server.id})`) : undefined;
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.connection ? withTimeout(this.connection.sendRequest("textDocument/references", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -6196,7 +7685,7 @@ stderr: ${stderr}` : ""));
     }), LSP_TIMEOUTS.request, `LSP references (${this.server.id})`) : undefined;
   }
   async diagnostics(filePath) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     const uri = pathToFileURL(absPath).href;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.diagnosticSettleDelay));
@@ -6251,7 +7740,7 @@ stderr: ${stderr}` : ""));
     throw new Error(`Unable to retrieve diagnostics from ${this.server.id}: request timed out or is unsupported.`);
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.connection ? withTimeout(this.connection.sendRequest("textDocument/rename", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -6290,19 +7779,19 @@ import { tool as tool5 } from "@opencode-ai/plugin/tool";
 
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   readFileSync as readFileSync5,
   statSync as statSync4,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname7, extname as extname2, join as join10, resolve as resolve4 } from "path";
+import { dirname as dirname8, extname as extname3, join as join11, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname7(resolve4(filePath));
+    return server.root(filePath) ?? dirname8(resolve5(filePath));
   }
-  return dirname7(resolve4(filePath));
+  return dirname8(resolve5(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -6321,8 +7810,8 @@ function formatServerLookupError(result) {
   return `No LSP server configured for extension: ${result.extension}`;
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve4(filePath);
-  const ext = extname2(absPath);
+  const absPath = resolve5(filePath);
+  const ext = extname3(absPath);
   const result = findServerForExtension(ext, absPath);
   if (result.status !== "found") {
     log("[lsp] withLspClient: server not found", {
@@ -6332,7 +7821,7 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname7(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname8(absPath);
   log("[lsp] withLspClient: selected server", {
     filePath: absPath,
     extension: ext,
@@ -6695,14 +8184,14 @@ var BINARY_PREFIXES = [
 var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";
 // src/tools/smartfetch/tool.ts
 import os3 from "os";
-import path9 from "path";
+import path10 from "path";
 import {
   tool as tool6
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
-import { mkdir, writeFile } from "fs/promises";
-import path6 from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -6721,14 +8210,14 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
   return `${subject} content omitted because it exceeds the download limit.`;
 }
 async function saveBinary(binaryDir, data, contentType, filename) {
-  await mkdir(binaryDir, { recursive: true });
+  await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path6.parse(initialName);
+  const parsed = path7.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path6.join(binaryDir, candidateName);
+    const file = path7.join(binaryDir, candidateName);
     try {
-      await writeFile(file, data, { flag: "wx" });
+      await writeFile2(file, data, { flag: "wx" });
       return file;
     } catch (error) {
       if (typeof error === "object" && error && "code" in error && error.code === "EEXIST") {
@@ -6744,7 +8233,7 @@ async function saveBinary(binaryDir, data, contentType, filename) {
 import { LRUCache } from "lru-cache";
 
 // src/tools/smartfetch/network.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/tools/smartfetch/utils.ts
 import { Readability } from "@mozilla/readability";
@@ -7463,7 +8952,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path7.parse(name);
+  const parsed = path8.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -7633,9 +9122,9 @@ function isInvalidLlmsResult(fetchResult) {
 }
 
 // src/tools/smartfetch/secondary-model.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile } from "fs/promises";
-import path8 from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import path9 from "path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -7661,8 +9150,8 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path8.join(baseDir, file);
-    if (existsSync10(fullPath))
+    const fullPath = path9.join(baseDir, file);
+    if (existsSync11(fullPath))
       return fullPath;
   }
   return;
@@ -7671,14 +9160,14 @@ async function readOpenCodeConfigFile(configPath) {
   if (!configPath)
     return;
   try {
-    const content = await readFile(configPath, "utf8");
+    const content = await readFile2(configPath, "utf8");
     return JSON.parse(stripJsonComments(content));
   } catch {
     return;
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path8.join(directory, ".opencode");
+  const projectDir = path9.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -7839,7 +9328,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z5 = tool6.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path9.join(os3.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path10.join(os3.tmpdir(), "opencode-smartfetch");
   return tool6({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -8385,12 +9874,14 @@ var OhMyOpenCodeLite = async (ctx) => {
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   const foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
+  const sessionAgentMap = new Map;
   const todoContinuationHook = createTodoContinuationHook(ctx, {
     maxContinuations: config.todoContinuation?.maxContinuations ?? 5,
     cooldownMs: config.todoContinuation?.cooldownMs ?? 3000,
     autoEnable: config.todoContinuation?.autoEnable ?? false,
     autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4
   });
+  const interviewManager = createInterviewManager(ctx, config);
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -8510,6 +10001,7 @@ var OhMyOpenCodeLite = async (ctx) => {
           description: "Enable auto-continuation \u2014 orchestrator keeps working through incomplete todos"
         };
       }
+      interviewManager.registerCommand(opencodeConfig);
     },
     event: async (input) => {
       await foregroundFallback.handleEvent(input.event);
@@ -8520,11 +10012,30 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionStatus(input.event);
       await backgroundManager.handleSessionDeleted(input.event);
       await multiplexerSessionManager.onSessionDeleted(input.event);
+      await interviewManager.handleEvent(input);
     },
     "command.execute.before": async (input, output) => {
       await todoContinuationHook.handleCommandExecuteBefore(input, output);
+      await interviewManager.handleCommandExecuteBefore(input, output);
     },
     "chat.headers": chatHeadersHook["chat.headers"],
+    "chat.message": async (input) => {
+      if (input.agent) {
+        sessionAgentMap.set(input.sessionID, input.agent);
+      }
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : undefined;
+      if (agentName === "orchestrator") {
+        const alreadyInjected = output.system.some((s) => typeof s === "string" && s.includes("<Role>") && s.includes("orchestrator"));
+        if (!alreadyInjected) {
+          const { ORCHESTRATOR_PROMPT: ORCHESTRATOR_PROMPT2 } = await Promise.resolve().then(() => exports_orchestrator);
+          output.system[0] = ORCHESTRATOR_PROMPT2 + (output.system[0] ? `
+
+` + output.system[0] : "");
+        }
+      }
+    },
     "experimental.chat.messages.transform": async (input, output) => {
       const typedOutput = output;
       await phaseReminderHook["experimental.chat.messages.transform"](input, typedOutput);