oh-my-opencode-slim 2.0.5 → 2.1.0

package/dist/index.js

@@ -6344,9 +6344,9 @@ var require_URL = __commonJS((exports, module) => {
         s += "#" + this.fragment;
       return s;
     },
-    resolve: function(relative2) {
+    resolve: function(relative3) {
       var base = this;
-      var r = new URL4(relative2);
+      var r = new URL4(relative3);
       var t = new URL4;
       if (r.scheme !== undefined) {
         t.scheme = r.scheme;
@@ -6398,33 +6398,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path19) {
-        if (!path19)
-          return path19;
+      function remove_dot_segments(path20) {
+        if (!path20)
+          return path20;
         var output = "";
-        while (path19.length > 0) {
-          if (path19 === "." || path19 === "..") {
-            path19 = "";
+        while (path20.length > 0) {
+          if (path20 === "." || path20 === "..") {
+            path20 = "";
             break;
           }
-          var twochars = path19.substring(0, 2);
-          var threechars = path19.substring(0, 3);
-          var fourchars = path19.substring(0, 4);
+          var twochars = path20.substring(0, 2);
+          var threechars = path20.substring(0, 3);
+          var fourchars = path20.substring(0, 4);
           if (threechars === "../") {
-            path19 = path19.substring(3);
+            path20 = path20.substring(3);
           } else if (twochars === "./") {
-            path19 = path19.substring(2);
+            path20 = path20.substring(2);
           } else if (threechars === "/./") {
-            path19 = "/" + path19.substring(3);
-          } else if (twochars === "/." && path19.length === 2) {
-            path19 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path19.length === 3) {
-            path19 = "/" + path19.substring(4);
+            path20 = "/" + path20.substring(3);
+          } else if (twochars === "/." && path20.length === 2) {
+            path20 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path20.length === 3) {
+            path20 = "/" + path20.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path19.match(/(\/?([^\/]*))/)[0];
+            var segment = path20.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path19 = path19.substring(segment.length);
+            path20 = path20.substring(segment.length);
           }
         }
         return output;
@@ -18337,36 +18337,7 @@ var require_turndown_cjs = __commonJS((exports, module) => {
   module.exports = TurndownService;
 });
 
-// src/cli/paths.ts
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-function getDefaultOpenCodeConfigDir() {
-  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
-  return join(userConfigDir, "opencode");
-}
-function getCustomOpenCodeConfigDir() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  return configDir || undefined;
-}
-function getConfigDir() {
-  const customConfigDir = getCustomOpenCodeConfigDir();
-  if (customConfigDir) {
-    return customConfigDir;
-  }
-  return getDefaultOpenCodeConfigDir();
-}
-function getConfigSearchDirs() {
-  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
-  return dirs.filter((dir, index) => {
-    return Boolean(dir) && dirs.indexOf(dir) === index;
-  });
-}
-function getOpenCodeConfigPaths() {
-  const configDir = getConfigDir();
-  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
-}
-
-// src/cli/custom-skills.ts
+// src/cli/custom-skills-registry.ts
 var CUSTOM_SKILLS = [
   {
     name: "simplify",
@@ -18404,6 +18375,12 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/oh-my-opencode-slim"
   },
+  {
+    name: "release-smoke-test",
+    description: "Validate packed release candidates and bugfixes before public publish",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/release-smoke-test"
+  },
   {
     name: "worktrees",
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
@@ -18412,6 +18389,35 @@ var CUSTOM_SKILLS = [
   }
 ];
 
+// src/cli/paths.ts
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+
 // src/cli/skills.ts
 var PERMISSION_ONLY_SKILLS = [
   {
@@ -18556,7 +18562,7 @@ var CouncilConfigSchema = z.object({
   default_preset: z.string().default("default"),
   councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
   councillor_retries: z.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries."),
-  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly.")
+  master: z.unknown().optional().describe("DEPRECATED - ignored. Council agent synthesizes directly.")
 }).transform((data) => {
   const deprecated = [];
   if (data.master !== undefined)
@@ -18671,7 +18677,13 @@ var AgentOverrideConfigSchema = z2.object({
   options: z2.record(z2.string(), z2.unknown()).optional(),
   displayName: z2.string().min(1).optional()
 }).strict();
-var MultiplexerTypeSchema = z2.enum(["auto", "tmux", "zellij", "none"]);
+var MultiplexerTypeSchema = z2.enum([
+  "auto",
+  "tmux",
+  "zellij",
+  "herdr",
+  "none"
+]);
 var MultiplexerLayoutSchema = z2.enum([
   "main-horizontal",
   "main-vertical",
@@ -18740,24 +18752,13 @@ var AcpAgentConfigSchema = z2.object({
   permissionMode: AcpAgentPermissionModeSchema.default("ask")
 }).strict();
 var AcpAgentsConfigSchema = z2.record(z2.string(), AcpAgentConfigSchema);
-function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
+function rejectOrchestratorPromptOnOrchestrator(overrides, ctx, pathPrefix) {
   for (const [name, override] of Object.entries(overrides)) {
-    const isBuiltInOrAlias = ALL_AGENT_NAMES.includes(name) || AGENT_ALIASES[name] !== undefined;
-    if (!isBuiltInOrAlias) {
-      continue;
-    }
-    if (override.prompt !== undefined) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: [...pathPrefix, name, "prompt"],
-        message: "prompt is only supported for custom agents"
-      });
-    }
-    if (override.orchestratorPrompt !== undefined) {
+    if (name === "orchestrator" && override.orchestratorPrompt !== undefined) {
       ctx.addIssue({
         code: z2.ZodIssueCode.custom,
         path: [...pathPrefix, name, "orchestratorPrompt"],
-        message: "orchestratorPrompt is only supported for custom agents"
+        message: "orchestratorPrompt is not supported for the orchestrator agent"
       });
     }
   }
@@ -18765,6 +18766,7 @@ function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
 var PluginConfigSchema = z2.object({
   preset: z2.string().optional(),
   setDefaultAgent: z2.boolean().optional(),
+  compactSidebar: z2.boolean().optional().describe("Use the compact TUI sidebar layout when enabled."),
   autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
   presets: z2.record(z2.string(), PresetSchema).optional(),
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
@@ -18783,11 +18785,14 @@ var PluginConfigSchema = z2.object({
   acpAgents: AcpAgentsConfigSchema.optional()
 }).superRefine((value, ctx) => {
   if (value.agents) {
-    validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
+    rejectOrchestratorPromptOnOrchestrator(value.agents, ctx, ["agents"]);
   }
   if (value.presets) {
     for (const [presetName, preset] of Object.entries(value.presets)) {
-      validateCustomOnlyPromptFields(preset, ctx, ["presets", presetName]);
+      rejectOrchestratorPromptOnOrchestrator(preset, ctx, [
+        "presets",
+        presetName
+      ]);
     }
   }
 });
@@ -18874,6 +18879,7 @@ function mergePluginConfigs(base, override) {
     ...base,
     ...override,
     agents: deepMerge(base.agents, override.agents),
+    presets: deepMerge(base.presets, override.presets),
     tmux: deepMerge(base.tmux, override.tmux),
     multiplexer: deepMerge(base.multiplexer, override.multiplexer),
     interview: deepMerge(base.interview, override.interview),
@@ -18945,15 +18951,33 @@ function loadPluginConfig(directory, options) {
   }
   return config;
 }
-function loadAgentPrompt(agentName, preset) {
+function loadAgentPrompt(agentName, optionsOrPreset) {
+  let preset;
+  let projectDirectory;
+  if (typeof optionsOrPreset === "string") {
+    preset = optionsOrPreset;
+  } else if (optionsOrPreset && typeof optionsOrPreset === "object") {
+    preset = optionsOrPreset.preset;
+    projectDirectory = optionsOrPreset.projectDirectory;
+  }
   const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
-  const promptSearchDirs = getConfigSearchDirs().flatMap((configDir) => {
-    const promptsDir = path.join(configDir, PROMPTS_DIR_NAME);
-    return presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
-  });
-  const result = {};
+  const searchDirs = [];
+  if (projectDirectory && presetDirName) {
+    searchDirs.push(path.join(projectDirectory, ".opencode", PROMPTS_DIR_NAME, presetDirName));
+  }
+  if (projectDirectory) {
+    searchDirs.push(path.join(projectDirectory, ".opencode", PROMPTS_DIR_NAME));
+  }
+  if (presetDirName) {
+    for (const userDir of getConfigSearchDirs()) {
+      searchDirs.push(path.join(userDir, PROMPTS_DIR_NAME, presetDirName));
+    }
+  }
+  for (const userDir of getConfigSearchDirs()) {
+    searchDirs.push(path.join(userDir, PROMPTS_DIR_NAME));
+  }
   const readFirstPrompt = (fileName, errorPrefix) => {
-    for (const dir of promptSearchDirs) {
+    for (const dir of searchDirs) {
       const promptPath = path.join(dir, fileName);
       if (!fs.existsSync(promptPath)) {
         continue;
@@ -18966,6 +18990,7 @@ function loadAgentPrompt(agentName, preset) {
     }
     return;
   };
+  const result = {};
   result.prompt = readFirstPrompt(`${agentName}.md`, "Error reading prompt file");
   result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
   return result;
@@ -19113,13 +19138,10 @@ async function extractSessionResult(client, sessionId, options) {
 
 // src/agents/orchestrator.ts
 function resolvePrompt(base, customPrompt, customAppendPrompt) {
-  if (customPrompt)
-    return customPrompt;
-  if (customAppendPrompt)
-    return `${base}
+  const effectiveBase = customPrompt !== undefined ? customPrompt : base;
+  return customAppendPrompt !== undefined ? `${effectiveBase}
 
-${customAppendPrompt}`;
-  return base;
+${customAppendPrompt}` : effectiveBase;
 }
 var AGENT_DESCRIPTIONS = {
   explorer: `@explorer
@@ -19162,7 +19184,7 @@ var AGENT_DESCRIPTIONS = {
 - Permissions: read_files, write_files
 - Stats: 2x faster code edits, 1/2 cost of orchestrator
 - Weakness: design, taste
-- Tools/Constraints: Execution-focused—no research, no architectural decisions
+- Tools/Constraints: Execution-focused-no 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 • Parallelization benefits: Task involves multiple folders and multiple files modification, scoping work per folder and spawning parallel @fixers for each folder.
 - **Don't delegate when:** Needs discovery/research/decisions • Single small change (<20 lines, one file) • Unclear requirements needing iteration • Explaining to fixer > doing • Tight integration with your current work • Requires design taste, visual hierarchy, interaction polish, responsive layout decisions, animation/motion, component feel, or UI copy/design trade-offs
 - **Rule of thumb:** Headless/mechanical implementation → @fixer. User-visible design or polish → @designer. If @designer already set direction, @fixer may only do bounded mechanical follow-up that preserves that design exactly.`,
@@ -19181,12 +19203,12 @@ var AGENT_DESCRIPTIONS = {
 - Lane: Visual/media analysis isolated from orchestrator context
 - Role: Visual analysis specialist for images, PDFs, and diagrams
 - Permissions: Read files
-- Stats: Saves main context tokens — Observer processes raw files, returns structured observations
+- Stats: Saves main context tokens - Observer processes raw files, returns structured observations
 - Capabilities: Interprets images, screenshots, PDFs, and diagrams via native read tool; extracts UI elements, layouts, text, relationships
 - **Delegate when:** Need to analyze a multimedia file• Extract information
 - **Don't delegate when:** Plain text files that Read can handle directly • Files that need editing afterward (need literal content from Read)
-- **Rule of thumb:** Even if your model supports vision, delegate visual analysis to @observer — it isolates large image/PDF bytes from your context window, returning only concise structured text. Need exact file contents for routing? → Read only the minimal context yourself.
-- **IMPORTANT:** When delegating to @observer, always include the **full file path** in the prompt so it can read the file. Example: "Analyze the screenshot at /path/to/file.png — describe the UI elements and error messages."`
+- **Rule of thumb:** Even if your model supports vision, delegate visual analysis to @observer - it isolates large image/PDF bytes from your context window, returning only concise structured text. Need exact file contents for routing? → Read only the minimal context yourself.
+- **IMPORTANT:** When delegating to @observer, always include the **full file path** in the prompt so it can read the file. Example: "Analyze the screenshot at /path/to/file.png - describe the UI elements and error messages."`
 };
 var VALIDATION_ROUTING = [
   "- Route UI/UX validation and review to @designer",
@@ -19384,7 +19406,7 @@ function createReadOnlyAgentPermission() {
 }
 
 // src/agents/council.ts
-var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestration system that runs consensus across multiple models.
+var COUNCIL_AGENT_PROMPT = `You are the Council agent - a multi-LLM orchestration system that runs consensus across multiple models.
 
 **Tool**: You have access to the \`council_session\` tool. You also have read-only codebase inspection tools. You do not have write, edit, shell, or subagent-delegation tools.
 
@@ -19400,9 +19422,9 @@ var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestrat
 4. Follow the Synthesis Process below
 5. Present the result to the user
 
-**Synthesis Process** (MANDATORY — follow in order):
+**Synthesis Process** (MANDATORY - follow in order):
 1. Read the original user prompt
-2. Review each councillor's response individually — note each councillor's key insight and unique contribution by name
+2. Review each councillor's response individually - note each councillor's key insight and unique contribution by name
 3. Identify agreements and contradictions between councillors
 4. Resolve contradictions with explicit reasoning
 5. Synthesize the optimal final answer
@@ -19416,7 +19438,7 @@ var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestrat
 - Do not omit per-councillor details from the final response
 - Do not collapse the output into only a final summary
 - Be transparent about trade-offs when different approaches have valid pros/cons
-- Don't just average responses — choose the best approach and improve upon it
+- Don't just average responses - choose the best approach and improve upon it
 
 ${READONLY_FILE_OPERATIONS_RULES}
 
@@ -19477,10 +19499,10 @@ ${cr.result}`;
   }).join(`
 
 `);
-  const failedSection = councillorResults.filter((cr) => cr.status !== "completed").map((cr) => `**${cr.name}**: ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
+  const failedSection = councillorResults.filter((cr) => cr.status !== "completed").map((cr) => `**${cr.name}**: ${cr.status} - ${cr.error ?? "Unknown"}`).join(`
 `);
   if (completedWithResults.length === 0) {
-    const errorDetails = councillorResults.map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}): ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
+    const errorDetails = councillorResults.map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}): ${cr.status} - ${cr.error ?? "Unknown"}`).join(`
 `);
     return `---
 
@@ -19538,12 +19560,12 @@ You CANNOT edit files, write files, run shell commands, or delegate to other age
 ${NO_SHELL_READONLY_FILE_OPERATIONS_RULES}
 
 **Behavior**:
-- **Examine the codebase** before answering — your read access is what makes   council valuable. Don't guess at code you can see.
+- **Examine the codebase** before answering - your read access is what makes   council valuable. Don't guess at code you can see.
 - Analyze the problem thoroughly
 - Provide a complete, well-reasoned response
 - Focus on the quality and correctness of your solution
 - Be direct and concise
-- Don't be influenced by what other councillors might say — you won't see   their responses
+- Don't be influenced by what other councillors might say - you won't see   their responses
 
 **Output**:
 - Give your honest assessment
@@ -19574,7 +19596,7 @@ var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who crea
 
 **Typography**
 - Choose distinctive, characterful fonts that elevate aesthetics
-- Avoid generic defaults (Arial, Inter)—opt for unexpected, beautiful choices
+- Avoid generic defaults (Arial, Inter)-opt for unexpected, beautiful choices
 - Pair display fonts with refined body fonts for hierarchy
 
 **Color & Theme**
@@ -19591,7 +19613,7 @@ var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who crea
 
 **Spatial Composition**
 - Break conventions: asymmetry, overlap, diagonal flow, grid-breaking
-- Generous negative space OR controlled density—commit to the choice
+- Generous negative space OR controlled density-commit to the choice
 - Unexpected layouts that guide the eye
 
 **Visual Depth**
@@ -19600,7 +19622,7 @@ var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who crea
 - Contextual effects that match the aesthetic (grain overlays, custom cursors)
 
 **Styling Approach**
-- Default to Tailwind CSS utility classes when available—fast, maintainable, consistent
+- Default to Tailwind CSS utility classes when available-fast, maintainable, consistent
 - Use custom CSS when the vision requires it: complex animations, unique effects, advanced compositions
 - Balance utility-first speed with creative freedom where it matters
 
@@ -19612,7 +19634,7 @@ var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who crea
 ## Constraints
 - Respect existing design systems when present
 - Leverage component libraries where available
-- Prioritize visual excellence—code perfection comes second
+- Prioritize visual excellence-code perfection comes second
 - Use grounded, normal, regular english - don't use jargon or overly technical language
 
 ${WRITABLE_FILE_OPERATIONS_RULES}
@@ -19716,7 +19738,7 @@ ${WRITABLE_FILE_OPERATIONS_RULES}
 - NO external research (no websearch, context7, gh_grep)
 - NO delegation or spawning subagents
 - No multi-step research/planning; minimal execution sequence ok
-- If context is insufficient: use grep/glob/read directly — do not delegate
+- If context is insufficient: use grep/glob/read directly - do not delegate
 - Only ask for missing inputs you truly cannot retrieve yourself
 - Do not act as the primary reviewer; implement requested changes and surface obvious issues briefly
 
@@ -19806,21 +19828,21 @@ ${customAppendPrompt}`;
 }
 
 // src/agents/observer.ts
-var OBSERVER_PROMPT = `You are Observer — a visual analysis specialist.
+var OBSERVER_PROMPT = `You are Observer - a visual analysis specialist.
 
 **Role**: Interpret images, screenshots, PDFs, and diagrams. Extract structured observations for the Orchestrator to act on.
 
 **Behavior**:
 - Read the file(s) specified in the prompt
-- Analyze visual content — layouts, UI elements, text, relationships, flows
-- For screenshots with text/code/errors: extract the **exact text** via OCR — never paraphrase error messages or code
+- Analyze visual content - layouts, UI elements, text, relationships, flows
+- For screenshots with text/code/errors: extract the **exact text** via OCR - never paraphrase error messages or code
 - For multiple files: analyze each, then compare or relate as requested
 - Return ONLY the extracted information relevant to the goal
-- If the image is unclear, blurry, or partially visible: state what you CAN see and explicitly note what is uncertain — never guess or fabricate details
+- If the image is unclear, blurry, or partially visible: state what you CAN see and explicitly note what is uncertain - never guess or fabricate details
 
 **Constraints**:
 - READ-ONLY: Analyze and report, don't modify files
-- Save context tokens — the Orchestrator never processes the raw file
+- Save context tokens - the Orchestrator never processes the raw file
 - Match the language of the request
 - If info not found, state clearly what's missing
 
@@ -19837,7 +19859,7 @@ ${customAppendPrompt}`;
   }
   return {
     name: "observer",
-    description: "Visual analysis. Use for interpreting images, screenshots, PDFs, and diagrams — extracts structured observations without loading raw files into main context. Requires a vision-capable model.",
+    description: "Visual analysis. Use for interpreting images, screenshots, PDFs, and diagrams - extracts structured observations without loading raw files into main context. Requires a vision-capable model.",
     config: {
       model,
       temperature: 0.1,
@@ -19974,7 +19996,7 @@ function applyOverrides(agent, override) {
   if (override.model) {
     if (Array.isArray(override.model)) {
       agent._modelArray = override.model.map((m) => typeof m === "string" ? { id: m } : m);
-      agent.config.model = undefined;
+      agent.config.model = agent._modelArray[0].id;
     } else {
       agent.config.model = override.model;
     }
@@ -20061,7 +20083,7 @@ var SUBAGENT_FACTORIES = {
   council: createCouncilAgent,
   councillor: createCouncillorAgent
 };
-function createAgents(config) {
+function createAgents(config, options) {
   const disabled = getDisabledAgents(config);
   if (!config?.council) {
     disabled.add("council");
@@ -20082,8 +20104,17 @@ function createAgents(config) {
     return primaryModel ?? DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).filter(([name]) => !disabled.has(name)).map(([name, factory]) => {
-    const customPrompts = loadAgentPrompt(name, config?.preset);
-    return factory(getModelForAgent(name), customPrompts.prompt, customPrompts.appendPrompt);
+    const agent = factory(getModelForAgent(name), undefined, undefined);
+    const customPrompts = loadAgentPrompt(name, {
+      preset: config?.preset,
+      projectDirectory: options?.projectDirectory
+    });
+    const override = getAgentOverride(config, name);
+    const inlinePrompt = override?.prompt;
+    const defaultPrompt = agent.config.prompt ?? "";
+    const basePrompt = inlinePrompt !== undefined ? inlinePrompt : defaultPrompt;
+    agent.config.prompt = resolvePrompt(basePrompt, customPrompts.prompt, customPrompts.appendPrompt);
+    return agent;
   });
   const customAgentNames = getCustomAgentNames(config).map(normalizeCustomAgentName).filter((name) => name.length > 0).filter((name) => {
     if (!isSafeCustomAgentName(name)) {
@@ -20100,7 +20131,10 @@ function createAgents(config) {
       console.warn(`[oh-my-opencode] Custom agent '${name}' skipped: 'model' is required`);
       return [];
     }
-    const customPrompts = loadAgentPrompt(name, config?.preset);
+    const customPrompts = loadAgentPrompt(name, {
+      preset: config?.preset,
+      projectDirectory: options?.projectDirectory
+    });
     return [
       buildCustomAgentDefinition(name, override, customPrompts.prompt, customPrompts.appendPrompt)
     ];
@@ -20157,8 +20191,15 @@ function createAgents(config) {
   ];
   const orchestratorOverride = getAgentOverride(config, "orchestrator");
   const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
-  const orchestratorPrompts = loadAgentPrompt("orchestrator", config?.preset);
-  const orchestrator = createOrchestratorAgent(orchestratorModel, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt, disabled);
+  const orchestratorPrompts = loadAgentPrompt("orchestrator", {
+    preset: config?.preset,
+    projectDirectory: options?.projectDirectory
+  });
+  const orchestrator = createOrchestratorAgent(orchestratorModel, undefined, undefined, disabled);
+  const inlineOrchestratorPrompt = orchestratorOverride?.prompt;
+  const defaultOrchestratorPrompt = orchestrator.config.prompt ?? "";
+  const baseOrchestratorPrompt = inlineOrchestratorPrompt !== undefined ? inlineOrchestratorPrompt : defaultOrchestratorPrompt;
+  orchestrator.config.prompt = resolvePrompt(baseOrchestratorPrompt, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt);
   applyDefaultPermissions(orchestrator, orchestratorOverride?.skills, config?.disabled_skills);
   if (orchestratorOverride) {
     applyOverrides(orchestrator, orchestratorOverride);
@@ -20172,7 +20213,7 @@ function createAgents(config) {
       displayNameMap.set(agent.name, agent.displayName);
     }
   }
-  const customOrchestratorPrompts = customSubAgents.map((agent) => {
+  const extraOrchestratorPromptsList = [...builtInSubAgents, ...customSubAgents].map((agent) => {
     const override = getAgentOverride(config, agent.name);
     return override?.orchestratorPrompt;
   }).filter((prompt) => Boolean(prompt));
@@ -20207,28 +20248,37 @@ function createAgents(config) {
     }
   }
   injectDisplayNames(orchestrator, displayNameMap);
-  const extraOrchestratorPrompts = [
-    ...customOrchestratorPrompts,
-    ...acpOrchestratorPrompts
-  ];
-  if (extraOrchestratorPrompts.length > 0) {
-    const rewrittenPrompts = extraOrchestratorPrompts.map((promptText) => {
-      let text = promptText;
-      for (const [internalName, displayName] of displayNameMap) {
-        text = text.replace(new RegExp(`@${escapeRegExp(internalName)}\\b`, "g"), `@${normalizeDisplayName(displayName)}`);
-      }
-      return text;
-    });
-    orchestrator.config.prompt = `${orchestrator.config.prompt}
+  const rewritePrompt = (promptText) => {
+    let text = promptText;
+    for (const [internalName, displayName] of displayNameMap) {
+      text = text.replace(new RegExp(`@${escapeRegExp(internalName)}\\b`, "g"), `@${normalizeDisplayName(displayName)}`);
+    }
+    return text;
+  };
+  const rewrittenOverrides = extraOrchestratorPromptsList.map(rewritePrompt);
+  const rewrittenAcps = acpOrchestratorPrompts.map(rewritePrompt);
+  let updatedPrompt = orchestrator.config.prompt ?? "";
+  if (rewrittenOverrides.length > 0) {
+    updatedPrompt = `${updatedPrompt}
+
+# Project-specific routing guidance
+
+${rewrittenOverrides.join(`
 
-${rewrittenPrompts.join(`
+`)}`;
+  }
+  if (rewrittenAcps.length > 0) {
+    updatedPrompt = `${updatedPrompt}
+
+${rewrittenAcps.join(`
 
 `)}`;
   }
+  orchestrator.config.prompt = updatedPrompt;
   return [orchestrator, ...allSubAgents];
 }
-function getAgentConfigs(config) {
-  const agents = createAgents(config);
+function getAgentConfigs(config, options) {
+  const agents = createAgents(config, options);
   const applyClassification = (name, sdkConfig) => {
     if (name === "council") {
       sdkConfig.mode = "all";
@@ -20368,6 +20418,8 @@ function log(message, data) {
 }
 
 // src/companion/manager.ts
+var activeExitListener = null;
+var activeManagers = new Set;
 function stateFilePath() {
   const xdg = process.env.XDG_DATA_HOME?.trim();
   const base = xdg && path3.isAbsolute(xdg) ? xdg : path3.join(os2.homedir(), ".local", "share");
@@ -20446,6 +20498,7 @@ class CompanionManager {
   }
   onLoad() {
     if (this.config?.enabled !== true) {
+      CompanionManager.disposeActiveManagers(this.id);
       try {
         if (!existsSync2(stateFilePath()))
           return;
@@ -20455,10 +20508,29 @@ class CompanionManager {
       } catch {}
       return;
     }
-    process.on("exit", () => this.onExit());
+    this.registerActiveManager();
     this.flush();
     this.spawnIfAvailable();
   }
+  registerActiveManager() {
+    for (const manager of [...activeManagers]) {
+      if (manager !== this && manager.id === this.id) {
+        manager.onExit();
+      }
+    }
+    activeManagers.add(this);
+    if (!activeExitListener) {
+      activeExitListener = () => CompanionManager.disposeActiveManagers();
+      process.on("exit", activeExitListener);
+    }
+  }
+  static disposeActiveManagers(sessionId) {
+    for (const manager of [...activeManagers]) {
+      if (sessionId && manager.id !== sessionId)
+        continue;
+      manager.onExit();
+    }
+  }
   onSessionStatus(input) {
     if (this.config?.enabled !== true)
       return;
@@ -20501,14 +20573,21 @@ class CompanionManager {
     this.flush();
   }
   onExit() {
-    if (this.config?.enabled !== true)
-      return;
+    activeManagers.delete(this);
     if (this.companionProcess) {
       try {
         this.companionProcess.kill();
       } catch {}
       this.companionProcess = null;
     }
+    if (activeManagers.size === 0 && activeExitListener) {
+      try {
+        process.removeListener("exit", activeExitListener);
+      } catch {}
+      activeExitListener = null;
+    }
+    if (this.config?.enabled !== true)
+      return;
     writeState((state) => {
       state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
     });
@@ -21003,7 +21082,7 @@ class CouncilManager {
       log(`[council-manager] Preset "${resolvedPreset}" has no councillors`);
       return {
         success: false,
-        error: `Preset "${resolvedPreset}" has no councillors configured. Note: the reserved key "master" is ignored — use councillor names as keys`,
+        error: `Preset "${resolvedPreset}" has no councillors configured. Note: the reserved key "master" is ignored - use councillor names as keys`,
         councillorResults: []
       };
     }
@@ -21039,7 +21118,7 @@ class CouncilManager {
   }
   async sendStartNotification(parentSessionId, councillorCount) {
     const message = [
-      `⎔ Council starting — ${councillorCount} councillors launching — ctrl+x ↓ to watch`,
+      `⎔ Council starting - ${councillorCount} councillors launching - ctrl+x ↓ to watch`,
       "",
       "[system status: continue without acknowledging this notification]"
     ].join(`
@@ -23179,17 +23258,65 @@ function preparePackageUpdate(version, packageName = PACKAGE_NAME, runtimePackag
 }
 
 // src/hooks/auto-update-checker/skill-sync.ts
+import * as crypto from "node:crypto";
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync6,
   lstatSync,
   mkdirSync as mkdirSync4,
-  mkdtempSync as mkdtempSync2,
   readdirSync as readdirSync2,
+  readFileSync as readFileSync6,
   renameSync as renameSync3,
-  rmSync as rmSync4
+  rmSync as rmSync4,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync5
 } from "node:fs";
+import * as os4 from "node:os";
 import * as path10 from "node:path";
+var localProcessToken = globalThis.OMO_SKILL_SYNC_PROCESS_TOKEN;
+if (!localProcessToken) {
+  localProcessToken = crypto.randomUUID();
+  globalThis.OMO_SKILL_SYNC_PROCESS_TOKEN = localProcessToken;
+}
+var PROCESS_TOKEN = localProcessToken;
+var ACQUIRED_LOCKS = new Set;
+var LEGACY_MANAGED_SKILL_HASHES = {};
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  const d = data;
+  if (d.schemaVersion !== 1)
+    return false;
+  if (typeof d.skills !== "object" || d.skills === null)
+    return false;
+  const allowedStatuses = new Set([
+    "managed",
+    "customized",
+    "deleted",
+    "conflict"
+  ]);
+  const skillsObj = d.skills;
+  for (const key of Object.keys(skillsObj)) {
+    const entry = skillsObj[key];
+    if (typeof entry !== "object" || entry === null)
+      return false;
+    if (typeof entry.status !== "string" || !allowedStatuses.has(entry.status))
+      return false;
+    if (typeof entry.packageVersion !== "string")
+      return false;
+    if (typeof entry.sourceHash !== "string")
+      return false;
+    if (typeof entry.lastManagedHash !== "string")
+      return false;
+    if (typeof entry.lastSeenHash !== "string")
+      return false;
+    if (entry.stagedPath !== undefined && typeof entry.stagedPath !== "string")
+      return false;
+    if (typeof entry.updatedAt !== "string")
+      return false;
+  }
+  return true;
+}
 function copyDirRecursive(src, dest) {
   const stat2 = lstatSync(src);
   if (stat2.isSymbolicLink()) {
@@ -23209,143 +23336,908 @@ function copyDirRecursive(src, dest) {
     copyFileSync2(src, dest);
   }
 }
-function syncBundledSkillsFromPackage(packageRoot) {
-  const installed = [];
-  const skippedExisting = [];
-  const failed = [];
-  const sourceSkillsDir = path10.join(packageRoot, "src", "skills");
-  try {
-    const stat2 = lstatSync(sourceSkillsDir);
-    if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
-      log(`[skill-sync] Source skills directory is not a valid directory: ${sourceSkillsDir}`);
-      return { installed, skippedExisting, failed };
+function computeDirectoryHash(dirPath) {
+  const hash = crypto.createHash("sha256");
+  const entriesToHash = [];
+  function traverse(currentDir) {
+    const entries = readdirSync2(currentDir);
+    for (const entry of entries) {
+      const absolutePath = path10.join(currentDir, entry);
+      const stat2 = lstatSync(absolutePath);
+      const relativePath = path10.relative(dirPath, absolutePath);
+      if (stat2.isSymbolicLink()) {
+        continue;
+      }
+      if (stat2.isDirectory()) {
+        entriesToHash.push({
+          relativePath,
+          absolutePath,
+          kind: "directory",
+          mode: stat2.mode
+        });
+        traverse(absolutePath);
+      } else if (stat2.isFile()) {
+        entriesToHash.push({
+          relativePath,
+          absolutePath,
+          kind: "file",
+          mode: stat2.mode
+        });
+      }
     }
-  } catch {
-    log(`[skill-sync] Source skills directory does not exist or is unreadable: ${sourceSkillsDir}`);
-    return { installed, skippedExisting, failed };
   }
-  const destSkillsDir = path10.join(getConfigDir(), "skills");
-  try {
-    if (!existsSync6(destSkillsDir)) {
-      mkdirSync4(destSkillsDir, { recursive: true });
+  traverse(dirPath);
+  entriesToHash.sort((a, b) => {
+    if (a.relativePath < b.relativePath)
+      return -1;
+    if (a.relativePath > b.relativePath)
+      return 1;
+    return 0;
+  });
+  for (const entry of entriesToHash) {
+    hash.update(entry.kind);
+    hash.update("\x00");
+    hash.update(entry.relativePath);
+    hash.update("\x00");
+    hash.update(String(entry.mode & 4095));
+    hash.update("\x00");
+    if (entry.kind === "file") {
+      const content = readFileSync6(entry.absolutePath);
+      hash.update(content);
     }
-  } catch (err) {
-    log(`[skill-sync] Failed to create destination skills directory: ${destSkillsDir}`, err);
   }
-  let entries = [];
+  return hash.digest("hex");
+}
+function isPidRunning(pid) {
   try {
-    entries = readdirSync2(sourceSkillsDir);
+    process.kill(pid, 0);
+    return true;
   } catch (err) {
-    log(`[skill-sync] Failed to read source skills directory: ${sourceSkillsDir}`, err);
-    return { installed, skippedExisting, failed };
+    return err.code === "EPERM";
   }
-  for (const entry of entries) {
-    const entryPath = path10.join(sourceSkillsDir, entry);
+}
+var CROSS_HOST_LOCK_EXPIRY_MS = 5 * 60 * 1000;
+function acquireLock(lockDir) {
+  const metadataPath2 = path10.join(lockDir, "owner.json");
+  const currentHost = os4.hostname();
+  const currentPid = process.pid;
+  const writeMetadata = () => {
     try {
-      if (entry.startsWith(".")) {
-        continue;
-      }
-      const entryStat = lstatSync(entryPath);
-      if (entryStat.isSymbolicLink() || !entryStat.isDirectory()) {
-        continue;
-      }
-      const skillMdPath = path10.join(entryPath, "SKILL.md");
+      const metadata = {
+        pid: currentPid,
+        host: currentHost,
+        time: Date.now(),
+        token: PROCESS_TOKEN
+      };
+      writeFileSync5(metadataPath2, JSON.stringify(metadata), "utf-8");
+    } catch {}
+  };
+  try {
+    mkdirSync4(lockDir);
+    writeMetadata();
+    ACQUIRED_LOCKS.add(path10.resolve(lockDir));
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+  }
+  try {
+    let shouldSteal = false;
+    let ageMs = 0;
+    if (existsSync6(metadataPath2)) {
       try {
-        const skillMdStat = lstatSync(skillMdPath);
-        if (skillMdStat.isSymbolicLink() || !skillMdStat.isFile()) {
-          continue;
+        const content = readFileSync6(metadataPath2, "utf-8");
+        const metadata = JSON.parse(content);
+        ageMs = Date.now() - metadata.time;
+        if (metadata.host === currentHost) {
+          if (!isPidRunning(metadata.pid)) {
+            log(`[skill-sync] Lock owner process ${metadata.pid} is not running on this host. Recovery path.`);
+            shouldSteal = true;
+          }
+        } else {
+          if (ageMs > CROSS_HOST_LOCK_EXPIRY_MS) {
+            log(`[skill-sync] Lock owned by different host ${metadata.host} has expired (${Math.round(ageMs / 1000)}s old). Reclaiming lock.`);
+            shouldSteal = true;
+          } else {
+            log(`[skill-sync] Lock is owned by different host ${metadata.host}; failing closed.`);
+          }
         }
       } catch {
-        continue;
+        shouldSteal = true;
       }
-      const destPath = path10.join(destSkillsDir, entry);
-      let destExists = false;
-      try {
-        lstatSync(destPath);
-        destExists = true;
-      } catch {}
-      if (destExists) {
-        log(`[skill-sync] Skill already exists in destination: ${entry}`);
-        skippedExisting.push(entry);
-        continue;
+    } else {
+      const stat2 = lstatSync(lockDir);
+      ageMs = Date.now() - stat2.mtimeMs;
+      if (ageMs > 30000) {
+        shouldSteal = true;
       }
-      const stagingDir = mkdtempSync2(path10.join(destSkillsDir, `.sync-staging-${entry}-`));
+    }
+    if (!shouldSteal)
+      return false;
+    log(`[skill-sync] Stealing/recovering lock directory.`);
+    rmSync4(lockDir, { recursive: true, force: true });
+    mkdirSync4(lockDir);
+    writeMetadata();
+    ACQUIRED_LOCKS.add(path10.resolve(lockDir));
+    return true;
+  } catch (err) {
+    log(`[skill-sync] Failed to check/recover lock at ${lockDir}:`, err);
+    return false;
+  }
+}
+function releaseLock(lockDir) {
+  const resolvedPath = path10.resolve(lockDir);
+  try {
+    let isOurLock = false;
+    const metadataPath2 = path10.join(lockDir, "owner.json");
+    if (existsSync6(metadataPath2)) {
       try {
-        copyDirRecursive(entryPath, stagingDir);
-        let destExistsLate = false;
-        try {
-          lstatSync(destPath);
-          destExistsLate = true;
-        } catch {}
-        if (destExistsLate) {
-          log(`[skill-sync] Destination path was created during staging for ${entry}, skipping promotion.`);
-          skippedExisting.push(entry);
+        const content = readFileSync6(metadataPath2, "utf-8");
+        const metadata = JSON.parse(content);
+        if (metadata.host === os4.hostname() && metadata.pid === process.pid && metadata.token === PROCESS_TOKEN) {
+          isOurLock = true;
         } else {
-          renameSync3(stagingDir, destPath);
-          installed.push(entry);
-          log(`[skill-sync] Successfully synced skill: ${entry}`);
+          isOurLock = false;
         }
       } catch (err) {
-        log(`[skill-sync] Failed to sync skill ${entry}:`, err);
-        failed.push(entry);
-      } finally {
-        try {
-          if (existsSync6(stagingDir)) {
-            rmSync4(stagingDir, { recursive: true, force: true });
-          }
-        } catch (err) {
-          log(`[skill-sync] Failed to clean up staging directory ${stagingDir}:`, err);
-        }
+        log(`[skill-sync] Lock owner.json is unreadable/corrupt:`, err);
+        isOurLock = false;
       }
-    } catch (err) {
-      log(`[skill-sync] Error processing source entry ${entry}:`, err);
-      failed.push(entry);
+    } else if (ACQUIRED_LOCKS.has(resolvedPath)) {
+      isOurLock = true;
     }
+    if (isOurLock) {
+      if (existsSync6(lockDir)) {
+        rmSync4(lockDir, { recursive: true, force: true });
+      }
+    } else if (existsSync6(lockDir)) {
+      log(`[skill-sync] Skipping lock directory removal: lock is not owned by this process/token or owner.json check failed.`);
+    }
+  } catch (err) {
+    log(`[skill-sync] Failed to release lock at ${lockDir}:`, err);
+  } finally {
+    ACQUIRED_LOCKS.delete(resolvedPath);
   }
-  return { installed, skippedExisting, failed };
 }
-
-// src/hooks/auto-update-checker/index.ts
-function createAutoUpdateCheckerHook(ctx, options = {}) {
-  const { autoUpdate = true, companion } = options;
-  let hasChecked = false;
-  return {
-    event: ({ event }) => {
-      if (event.type !== "session.created")
-        return;
-      if (hasChecked)
-        return;
-      const props = event.properties;
-      if (props?.info?.parentID)
-        return;
-      hasChecked = true;
-      setTimeout(async () => {
-        const localDevVersion = getLocalDevVersion(ctx.directory);
-        if (localDevVersion) {
-          log("[auto-update-checker] Local development mode");
-          return;
+function atomicReplaceDir(sourceDir, destDir) {
+  const parentDir = path10.dirname(destDir);
+  if (!existsSync6(parentDir)) {
+    mkdirSync4(parentDir, { recursive: true });
+  }
+  const uniqueSuffix = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  const stagingDir = path10.join(parentDir, `.staging-${path10.basename(destDir)}-${uniqueSuffix}`);
+  const backupDir = path10.join(parentDir, `.backup-${path10.basename(destDir)}-${uniqueSuffix}`);
+  let backupCreated = false;
+  try {
+    copyDirRecursive(sourceDir, stagingDir);
+    if (existsSync6(destDir)) {
+      renameSync3(destDir, backupDir);
+      backupCreated = true;
+    }
+    renameSync3(stagingDir, destDir);
+    if (backupCreated) {
+      rmSync4(backupDir, { recursive: true, force: true });
+    }
+  } catch (err) {
+    log(`[skill-sync] Error during atomic replace for ${destDir}. Rolling back:`, err);
+    if (backupCreated) {
+      try {
+        if (existsSync6(destDir)) {
+          rmSync4(destDir, { recursive: true, force: true });
         }
-        runBackgroundUpdateCheck(ctx, autoUpdate, companion).catch((err) => {
-          log("[auto-update-checker] Background update check failed:", err);
-        });
-      }, 0);
+        renameSync3(backupDir, destDir);
+      } catch (rollbackErr) {
+        log(`[skill-sync] Critical error during rollback for ${destDir}:`, rollbackErr);
+      }
     }
-  };
-}
-async function runBackgroundUpdateCheck(ctx, autoUpdate, companion) {
-  const pluginInfo = findPluginEntry(ctx.directory);
-  if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config");
-    return;
+    try {
+      if (existsSync6(stagingDir)) {
+        rmSync4(stagingDir, { recursive: true, force: true });
+      }
+    } catch {}
+    throw err;
   }
-  const cachedVersion = getCachedVersion();
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
-  if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)");
-    return;
+}
+function matchesArtifactPattern(entry, prefix2, skillName) {
+  if (!entry.startsWith(prefix2))
+    return false;
+  const rest = entry.slice(prefix2.length);
+  if (!rest.startsWith(`${skillName}-`))
+    return false;
+  const suffix2 = rest.slice(skillName.length + 1);
+  const firstPart = suffix2.split("-")[0];
+  const timestamp = Number(firstPart);
+  if (Number.isNaN(timestamp) || timestamp <= 0)
+    return false;
+  return true;
+}
+function recoverOrphanArtifacts(destSkillsDir, skillName) {
+  if (!existsSync6(destSkillsDir))
+    return false;
+  let hadArtifacts = false;
+  let entries = [];
+  try {
+    entries = readdirSync2(destSkillsDir);
+  } catch {
+    return false;
   }
-  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
-  const latestInfo = await getLatestCompatibleVersion(currentVersion, channel);
+  const backups = [];
+  const stagings = [];
+  for (const entry of entries) {
+    if (matchesArtifactPattern(entry, ".backup-", skillName)) {
+      backups.push(path10.join(destSkillsDir, entry));
+      hadArtifacts = true;
+    } else if (matchesArtifactPattern(entry, ".staging-", skillName)) {
+      stagings.push(path10.join(destSkillsDir, entry));
+      hadArtifacts = true;
+    }
+  }
+  const destPath = path10.join(destSkillsDir, skillName);
+  if (backups.length > 0) {
+    backups.sort();
+    const mostRecentBackup = backups[backups.length - 1];
+    if (!existsSync6(destPath)) {
+      backups.pop();
+      try {
+        renameSync3(mostRecentBackup, destPath);
+        log(`[skill-sync] Recovered backup for ${skillName} back to destination.`);
+      } catch (err) {
+        log(`[skill-sync] Failed to restore backup for ${skillName}:`, err);
+      }
+    }
+    for (const backup of backups) {
+      try {
+        rmSync4(backup, { recursive: true, force: true });
+      } catch (err) {
+        log(`[skill-sync] Failed to clean up backup folder ${backup}:`, err);
+      }
+    }
+  }
+  for (const staging of stagings) {
+    try {
+      rmSync4(staging, { recursive: true, force: true });
+    } catch (err) {
+      log(`[skill-sync] Failed to clean up staging folder ${staging}:`, err);
+    }
+  }
+  return hadArtifacts;
+}
+function removeManagedStagedPath(stagedPath, manifestDir, skillName) {
+  try {
+    const absoluteStagedPath = path10.resolve(stagedPath);
+    const absoluteAllowedRoot = path10.resolve(path10.join(manifestDir, "skill-updates"));
+    const relative2 = path10.relative(absoluteAllowedRoot, absoluteStagedPath);
+    const isUnderRoot = relative2 && !relative2.startsWith("..") && !path10.isAbsolute(relative2);
+    if (isUnderRoot) {
+      if (existsSync6(absoluteStagedPath)) {
+        rmSync4(absoluteStagedPath, { recursive: true, force: true });
+        log(`[skill-sync] Safely cleaned up staged path for ${skillName}: ${absoluteStagedPath}`);
+      }
+    } else {
+      log(`[skill-sync] Refusing to delete staged path for ${skillName}: path ${absoluteStagedPath} is not under managed root ${absoluteAllowedRoot}`);
+    }
+  } catch (err) {
+    log(`[skill-sync] Error while trying to verify and remove staged path for ${skillName} (${stagedPath}):`, err);
+  }
+}
+function syncBundledSkillsFromPackage(packageRoot, options = {}) {
+  const installed = [];
+  const skippedExisting = [];
+  const failed = [];
+  const staged = [];
+  const adopted = [];
+  const customized = [];
+  const sourceSkillsDir = path10.join(packageRoot, "src", "skills");
+  try {
+    const stat2 = lstatSync(sourceSkillsDir);
+    if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+      log(`[skill-sync] Source skills directory is not a valid directory: ${sourceSkillsDir}`);
+      return {
+        installed,
+        skippedExisting,
+        failed,
+        staged,
+        adopted,
+        customized
+      };
+    }
+  } catch {
+    log(`[skill-sync] Source skills directory does not exist or is unreadable: ${sourceSkillsDir}`);
+    return {
+      installed,
+      skippedExisting,
+      failed,
+      staged,
+      adopted,
+      customized
+    };
+  }
+  let packageVersion = "unknown";
+  try {
+    const pkgJsonPath = path10.join(packageRoot, "package.json");
+    if (existsSync6(pkgJsonPath)) {
+      const content = readFileSync6(pkgJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version) {
+        packageVersion = pkg.version;
+      }
+    }
+  } catch (err) {
+    log(`[skill-sync] Failed to read package version from ${packageRoot}:`, err);
+  }
+  const manifestDir = path10.join(getConfigDir(), ".oh-my-opencode-slim");
+  const lockDir = path10.join(manifestDir, "skills.lock");
+  try {
+    mkdirSync4(manifestDir, { recursive: true });
+  } catch (err) {
+    log(`[skill-sync] Failed to create manifest directory: ${manifestDir}`, err);
+  }
+  if (!acquireLock(lockDir)) {
+    log("[skill-sync] Failed to acquire lock for skill synchronization. Skipping.");
+    return {
+      installed,
+      skippedExisting,
+      failed: ["__lock__"],
+      staged,
+      adopted,
+      customized
+    };
+  }
+  try {
+    const manifestPath = path10.join(manifestDir, "skills-manifest.json");
+    let manifest = {
+      schemaVersion: 1,
+      updatedAt: new Date().toISOString(),
+      skills: {}
+    };
+    let isManifestCorrupt = false;
+    if (existsSync6(manifestPath)) {
+      try {
+        const content = readFileSync6(manifestPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (validateManifest(parsed)) {
+          manifest = parsed;
+        } else {
+          throw new Error("Manifest validation failed");
+        }
+      } catch (err) {
+        log("[skill-sync] Manifest is corrupt/unreadable. Failing closed.", err);
+        isManifestCorrupt = true;
+      }
+    }
+    const destSkillsDir = path10.join(getConfigDir(), "skills");
+    try {
+      if (!existsSync6(destSkillsDir)) {
+        mkdirSync4(destSkillsDir, { recursive: true });
+      }
+    } catch (err) {
+      log(`[skill-sync] Failed to create destination skills directory: ${destSkillsDir}`, err);
+    }
+    const skillsToProcess = (options.skills ?? CUSTOM_SKILLS).map((s) => ({
+      name: s.name,
+      sourcePath: s.sourcePath
+    }));
+    for (const skill of skillsToProcess) {
+      try {
+        const sourcePath = path10.join(packageRoot, skill.sourcePath);
+        try {
+          const stat2 = lstatSync(sourcePath);
+          if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+            continue;
+          }
+          const skillMdPath = path10.join(sourcePath, "SKILL.md");
+          const skillMdStat = lstatSync(skillMdPath);
+          if (skillMdStat.isSymbolicLink() || !skillMdStat.isFile()) {
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        const destPath = path10.join(destSkillsDir, skill.name);
+        const hadArtifacts = recoverOrphanArtifacts(destSkillsDir, skill.name);
+        let destExists = false;
+        let destIsDir = false;
+        try {
+          const destStat = lstatSync(destPath);
+          destExists = true;
+          destIsDir = destStat.isDirectory() && !destStat.isSymbolicLink();
+        } catch {}
+        if (destExists && !destIsDir) {
+          log(`[skill-sync] Skill ${skill.name} destination is a file or symlink (conflict). Skipping.`);
+          skippedExisting.push(skill.name);
+          const sourceHash2 = computeDirectoryHash(sourcePath);
+          const entry2 = manifest.skills[skill.name];
+          if (entry2?.stagedPath) {
+            removeManagedStagedPath(entry2.stagedPath, manifestDir, skill.name);
+          }
+          manifest.skills[skill.name] = {
+            status: "conflict",
+            packageVersion,
+            sourceHash: sourceHash2,
+            lastManagedHash: "",
+            lastSeenHash: "",
+            updatedAt: new Date().toISOString()
+          };
+          continue;
+        }
+        const sourceHash = computeDirectoryHash(sourcePath);
+        if (isManifestCorrupt) {
+          if (!destExists) {
+            try {
+              atomicReplaceDir(sourcePath, destPath);
+              installed.push(skill.name);
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+            } catch (err) {
+              log(`[skill-sync] Failed to install missing skill ${skill.name} (corrupt manifest mode):`, err);
+              failed.push(skill.name);
+            }
+          } else {
+            log(`[skill-sync] Skipping existing skill ${skill.name} because manifest is corrupt.`);
+            skippedExisting.push(skill.name);
+            const destHash2 = computeDirectoryHash(destPath);
+            if (destHash2 === sourceHash) {
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+            } else {
+              try {
+                const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (existsSync6(stagedSkillDir)) {
+                  rmSync4(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync4(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                manifest.skills[skill.name] = {
+                  status: "customized",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: "",
+                  lastSeenHash: destHash2,
+                  stagedPath: stagedSkillDir,
+                  updatedAt: new Date().toISOString()
+                };
+                staged.push(skill.name);
+                customized.push(skill.name);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for customized skill ${skill.name} during recovery:`, err);
+                manifest.skills[skill.name] = {
+                  status: "customized",
+                  packageVersion: "unknown",
+                  sourceHash: "",
+                  lastManagedHash: "",
+                  lastSeenHash: destHash2,
+                  updatedAt: new Date().toISOString()
+                };
+              }
+            }
+          }
+          continue;
+        }
+        const entry = manifest.skills[skill.name];
+        if (!destExists) {
+          if (entry && entry.status === "deleted") {
+            log(`[skill-sync] Skill ${skill.name} was deleted by user. Skipping.`);
+            skippedExisting.push(skill.name);
+            continue;
+          }
+          if (entry && entry.status !== "deleted") {
+            if (hadArtifacts) {
+              log(`[skill-sync] Managed skill ${skill.name} has backup/staging artifacts. Skipping delete, re-installing.`);
+              try {
+                atomicReplaceDir(sourcePath, destPath);
+                installed.push(skill.name);
+                manifest.skills[skill.name] = {
+                  status: "managed",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: sourceHash,
+                  lastSeenHash: sourceHash,
+                  updatedAt: new Date().toISOString()
+                };
+              } catch (err) {
+                log(`[skill-sync] Failed to re-install skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+              continue;
+            } else {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                delete entry.stagedPath;
+              }
+              const rawEntry = entry;
+              delete rawEntry.stagedVersion;
+              delete rawEntry.stagedHash;
+              entry.status = "deleted";
+              entry.updatedAt = new Date().toISOString();
+              log(`[skill-sync] Skill ${skill.name} was deleted by user (detected now). Skipping.`);
+              skippedExisting.push(skill.name);
+              continue;
+            }
+          }
+          try {
+            atomicReplaceDir(sourcePath, destPath);
+            installed.push(skill.name);
+            manifest.skills[skill.name] = {
+              status: "managed",
+              packageVersion,
+              sourceHash,
+              lastManagedHash: sourceHash,
+              lastSeenHash: sourceHash,
+              updatedAt: new Date().toISOString()
+            };
+            log(`[skill-sync] Successfully installed missing skill: ${skill.name}`);
+          } catch (err) {
+            log(`[skill-sync] Failed to install skill ${skill.name}:`, err);
+            failed.push(skill.name);
+          }
+          continue;
+        }
+        const destHash = computeDirectoryHash(destPath);
+        if (entry) {
+          if (entry.status === "managed") {
+            if (destHash === entry.lastManagedHash) {
+              if (destHash === sourceHash) {
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = sourceHash;
+                entry.updatedAt = new Date().toISOString();
+                skippedExisting.push(skill.name);
+              } else {
+                try {
+                  atomicReplaceDir(sourcePath, destPath);
+                  installed.push(skill.name);
+                  manifest.skills[skill.name] = {
+                    status: "managed",
+                    packageVersion,
+                    sourceHash,
+                    lastManagedHash: sourceHash,
+                    lastSeenHash: sourceHash,
+                    updatedAt: new Date().toISOString()
+                  };
+                  log(`[skill-sync] Updated managed skill: ${skill.name}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to update managed skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              }
+            } else {
+              if (destHash === sourceHash) {
+                manifest.skills[skill.name] = {
+                  status: "managed",
+                  packageVersion,
+                  sourceHash,
+                  lastManagedHash: sourceHash,
+                  lastSeenHash: sourceHash,
+                  updatedAt: new Date().toISOString()
+                };
+                skippedExisting.push(skill.name);
+              } else {
+                try {
+                  const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                  if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                    removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                  }
+                  if (existsSync6(stagedSkillDir)) {
+                    rmSync4(stagedSkillDir, { recursive: true, force: true });
+                  }
+                  mkdirSync4(stagedSkillDir, { recursive: true });
+                  copyDirRecursive(sourcePath, stagedSkillDir);
+                  entry.status = "customized";
+                  entry.lastSeenHash = destHash;
+                  entry.stagedPath = stagedSkillDir;
+                  entry.sourceHash = sourceHash;
+                  entry.packageVersion = packageVersion;
+                  entry.updatedAt = new Date().toISOString();
+                  staged.push(skill.name);
+                  customized.push(skill.name);
+                  skippedExisting.push(skill.name);
+                  log(`[skill-sync] Skill ${skill.name} is customized. Staged update at ${stagedSkillDir}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              }
+            }
+          } else if (entry.status === "customized") {
+            if (destHash === sourceHash) {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+              }
+              entry.status = "managed";
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              entry.sourceHash = sourceHash;
+              entry.packageVersion = packageVersion;
+              delete entry.stagedPath;
+              entry.updatedAt = new Date().toISOString();
+              adopted.push(skill.name);
+              skippedExisting.push(skill.name);
+              log(`[skill-sync] Customized skill ${skill.name} converged with current version. Adopted back to managed.`);
+            } else {
+              entry.lastSeenHash = destHash;
+              entry.updatedAt = new Date().toISOString();
+              if (destHash !== sourceHash && entry.sourceHash !== sourceHash) {
+                try {
+                  const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                  if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                    removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                  }
+                  if (existsSync6(stagedSkillDir)) {
+                    rmSync4(stagedSkillDir, { recursive: true, force: true });
+                  }
+                  mkdirSync4(stagedSkillDir, { recursive: true });
+                  copyDirRecursive(sourcePath, stagedSkillDir);
+                  entry.stagedPath = stagedSkillDir;
+                  entry.sourceHash = sourceHash;
+                  entry.packageVersion = packageVersion;
+                  staged.push(skill.name);
+                  customized.push(skill.name);
+                  skippedExisting.push(skill.name);
+                  log(`[skill-sync] Staged new update for customized skill ${skill.name} at ${stagedSkillDir}`);
+                } catch (err) {
+                  log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+                  failed.push(skill.name);
+                }
+              } else {
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+              }
+            }
+          } else if (entry.status === "deleted") {
+            if (destHash === sourceHash) {
+              entry.status = "managed";
+              entry.packageVersion = packageVersion;
+              entry.sourceHash = sourceHash;
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              entry.updatedAt = new Date().toISOString();
+              skippedExisting.push(skill.name);
+              adopted.push(skill.name);
+              log(`[skill-sync] Skill ${skill.name} re-created by user (matching current). Adopted as managed.`);
+            } else {
+              try {
+                const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                  removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                }
+                if (existsSync6(stagedSkillDir)) {
+                  rmSync4(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync4(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                entry.status = "customized";
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = destHash;
+                entry.stagedPath = stagedSkillDir;
+                entry.updatedAt = new Date().toISOString();
+                staged.push(skill.name);
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+                log(`[skill-sync] Skill ${skill.name} re-created by user (custom). Marked customized and staged.`);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for deleted/recreated skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+            }
+          } else if (entry.status === "conflict") {
+            if (destHash === sourceHash) {
+              if (entry.stagedPath) {
+                removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+              }
+              entry.status = "managed";
+              entry.packageVersion = packageVersion;
+              entry.sourceHash = sourceHash;
+              entry.lastManagedHash = sourceHash;
+              entry.lastSeenHash = sourceHash;
+              delete entry.stagedPath;
+              entry.updatedAt = new Date().toISOString();
+              adopted.push(skill.name);
+            } else {
+              try {
+                const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+                if (entry.stagedPath && entry.stagedPath !== stagedSkillDir) {
+                  removeManagedStagedPath(entry.stagedPath, manifestDir, skill.name);
+                }
+                if (existsSync6(stagedSkillDir)) {
+                  rmSync4(stagedSkillDir, { recursive: true, force: true });
+                }
+                mkdirSync4(stagedSkillDir, { recursive: true });
+                copyDirRecursive(sourcePath, stagedSkillDir);
+                entry.status = "customized";
+                entry.packageVersion = packageVersion;
+                entry.sourceHash = sourceHash;
+                entry.lastManagedHash = sourceHash;
+                entry.lastSeenHash = destHash;
+                entry.stagedPath = stagedSkillDir;
+                entry.updatedAt = new Date().toISOString();
+                staged.push(skill.name);
+                customized.push(skill.name);
+                skippedExisting.push(skill.name);
+                log(`[skill-sync] Conflicted skill ${skill.name} recovered as customized and staged at ${stagedSkillDir}`);
+              } catch (err) {
+                log(`[skill-sync] Failed to stage update for conflicted skill ${skill.name}:`, err);
+                failed.push(skill.name);
+              }
+            }
+          }
+        } else {
+          if (destHash === sourceHash) {
+            manifest.skills[skill.name] = {
+              status: "managed",
+              packageVersion,
+              sourceHash,
+              lastManagedHash: sourceHash,
+              lastSeenHash: sourceHash,
+              updatedAt: new Date().toISOString()
+            };
+            skippedExisting.push(skill.name);
+            adopted.push(skill.name);
+            log(`[skill-sync] Adopted existing matching skill: ${skill.name}`);
+          } else if (LEGACY_MANAGED_SKILL_HASHES[skill.name]?.includes(destHash)) {
+            try {
+              atomicReplaceDir(sourcePath, destPath);
+              installed.push(skill.name);
+              manifest.skills[skill.name] = {
+                status: "managed",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: sourceHash,
+                lastSeenHash: sourceHash,
+                updatedAt: new Date().toISOString()
+              };
+              log(`[skill-sync] Adopted and updated legacy skill: ${skill.name}`);
+            } catch (err) {
+              log(`[skill-sync] Failed to update legacy skill ${skill.name}:`, err);
+              failed.push(skill.name);
+            }
+          } else {
+            try {
+              const stagedSkillDir = path10.join(manifestDir, "skill-updates", packageVersion, skill.name);
+              if (existsSync6(stagedSkillDir)) {
+                rmSync4(stagedSkillDir, { recursive: true, force: true });
+              }
+              mkdirSync4(stagedSkillDir, { recursive: true });
+              copyDirRecursive(sourcePath, stagedSkillDir);
+              manifest.skills[skill.name] = {
+                status: "customized",
+                packageVersion,
+                sourceHash,
+                lastManagedHash: "",
+                lastSeenHash: destHash,
+                stagedPath: stagedSkillDir,
+                updatedAt: new Date().toISOString()
+              };
+              staged.push(skill.name);
+              customized.push(skill.name);
+              skippedExisting.push(skill.name);
+              log(`[skill-sync] Skill ${skill.name} is customized (no manifest entry). Staged update at ${stagedSkillDir}`);
+            } catch (err) {
+              log(`[skill-sync] Failed to stage update for customized skill ${skill.name}:`, err);
+              failed.push(skill.name);
+            }
+          }
+        }
+      } catch (err) {
+        log(`[skill-sync] Failed processing skill ${skill.name}:`, err);
+        failed.push(skill.name);
+      }
+    }
+    let manifestWriteFailed = false;
+    manifest.updatedAt = new Date().toISOString();
+    const tempManifestPath = `${manifestPath}.${Math.random().toString(36).slice(2, 9)}.tmp`;
+    try {
+      writeFileSync5(tempManifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+      renameSync3(tempManifestPath, manifestPath);
+    } catch (err) {
+      log("[skill-sync] Failed to write skills manifest atomically:", err);
+      manifestWriteFailed = true;
+      try {
+        if (existsSync6(tempManifestPath)) {
+          unlinkSync2(tempManifestPath);
+        }
+      } catch {}
+    }
+    if (manifestWriteFailed) {
+      failed.push("__manifest__");
+    }
+  } finally {
+    releaseLock(lockDir);
+  }
+  return {
+    installed,
+    skippedExisting,
+    failed,
+    staged,
+    adopted,
+    customized
+  };
+}
+
+// src/hooks/auto-update-checker/index.ts
+function createAutoUpdateCheckerHook(ctx, options = {}) {
+  const { autoUpdate = true, companion } = options;
+  let hasChecked = false;
+  return {
+    event: ({ event }) => {
+      if (event.type !== "session.created")
+        return;
+      if (hasChecked)
+        return;
+      const props = event.properties;
+      if (props?.info?.parentID)
+        return;
+      hasChecked = true;
+      setTimeout(async () => {
+        const localDevVersion = getLocalDevVersion(ctx.directory);
+        if (localDevVersion) {
+          log("[auto-update-checker] Local development mode");
+          return;
+        }
+        runBackgroundUpdateCheck(ctx, autoUpdate, companion).catch((err) => {
+          log("[auto-update-checker] Background update check failed:", err);
+        });
+      }, 0);
+    }
+  };
+}
+var hasReconciledAtStartup = false;
+async function runBackgroundUpdateCheck(ctx, autoUpdate, companion) {
+  if (!hasReconciledAtStartup) {
+    try {
+      const runtimePackageJsonPath = getCurrentRuntimePackageJsonPath();
+      if (runtimePackageJsonPath) {
+        hasReconciledAtStartup = true;
+        const packageRoot = path11.dirname(runtimePackageJsonPath);
+        log("[auto-update-checker] Running startup skill reconciliation");
+        const syncResult = syncBundledSkillsFromPackage(packageRoot);
+        if (syncResult.installed.length > 0) {
+          log(`[auto-update-checker] Startup skill sync installed: ${syncResult.installed.join(", ")}`);
+        }
+        if (syncResult.failed.length > 0) {
+          log(`[auto-update-checker] Startup skill sync failures: ${syncResult.failed.join(", ")}`);
+        }
+        if (syncResult.staged.length > 0) {
+          log(`[auto-update-checker] Startup skill sync staged: ${syncResult.staged.join(", ")}`);
+        }
+        if (syncResult.customized.length > 0) {
+          log(`[auto-update-checker] Startup skill sync customized: ${syncResult.customized.join(", ")}`);
+        }
+      } else {
+        log("[auto-update-checker] Could not resolve runtime package path for startup skill reconciliation");
+      }
+    } catch (err) {
+      log("[auto-update-checker] Startup skill reconciliation failed:", err);
+    }
+  }
+  const pluginInfo = findPluginEntry(ctx.directory);
+  if (!pluginInfo) {
+    log("[auto-update-checker] Plugin not found in config");
+    return;
+  }
+  const cachedVersion = getCachedVersion();
+  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+  if (!currentVersion) {
+    log("[auto-update-checker] No version found (cached or pinned)");
+    return;
+  }
+  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
+  const latestInfo = await getLatestCompatibleVersion(currentVersion, channel);
   if (latestInfo.unsafeReason === "unparseable-current-version") {
     log(`[auto-update-checker] Current version is not semver; skipping auto-update: ${currentVersion}`);
     if (latestInfo.latestMajorVersion) {
@@ -23388,12 +24280,16 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
   const installSuccess = await runBunInstallSafe(installDir);
   if (installSuccess) {
     let installedSkills = [];
+    let stagedSkills = [];
+    let customizedSkills = [];
     let companionUpdated = false;
     let companionWillRetry = false;
     const packageRoot = path11.join(installDir, "node_modules", PACKAGE_NAME);
     try {
       const syncResult = syncBundledSkillsFromPackage(packageRoot);
       installedSkills = syncResult.installed;
+      stagedSkills = syncResult.staged;
+      customizedSkills = syncResult.customized;
       if (syncResult.failed.length > 0) {
         log(`[auto-update-checker] Skill sync warnings/failures: ${syncResult.failed.join(", ")}`);
       }
@@ -23427,6 +24323,12 @@ Version is pinned. Update your plugin config to apply.`, "info", 8000);
     if (installedSkills.length > 0) {
       messageLines.push(`Added bundled skills: ${installedSkills.join(", ")}`);
     }
+    if (stagedSkills.length > 0) {
+      messageLines.push(`Staged skill updates: ${stagedSkills.join(", ")}`);
+    }
+    if (customizedSkills.length > 0) {
+      messageLines.push(`Customized skills: ${customizedSkills.join(", ")}`);
+    }
     if (companionUpdated) {
       messageLines.push("Companion updated.");
     } else if (companionWillRetry) {
@@ -23452,7 +24354,7 @@ async function runBunInstallSafe(installDir) {
       stdout: "pipe",
       stderr: "pipe"
     });
-    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), 60000));
+    const timeoutPromise = new Promise((resolve2) => setTimeout(() => resolve2("timeout"), 60000));
     const exitPromise = proc.exited.then(() => "completed");
     const result = await Promise.race([exitPromise, timeoutPromise]);
     if (result === "timeout") {
@@ -23617,7 +24519,7 @@ var AGENT_PREFIX = {
 class BackgroundJobBoard {
   jobs = new Map;
   counters = new Map;
-  terminalStateListener;
+  terminalStateListeners = [];
   maxReusablePerAgent;
   readContextMinLines;
   readContextMaxFiles;
@@ -23626,8 +24528,19 @@ class BackgroundJobBoard {
     this.readContextMinLines = options.readContextMinLines ?? 10;
     this.readContextMaxFiles = options.readContextMaxFiles ?? 8;
   }
+  addTerminalStateListener(listener) {
+    this.terminalStateListeners.push(listener);
+  }
+  removeTerminalStateListener(listener) {
+    this.terminalStateListeners = this.terminalStateListeners.filter((entry) => entry !== listener);
+  }
   setTerminalStateListener(listener) {
-    this.terminalStateListener = listener;
+    this.terminalStateListeners = listener ? [listener] : [];
+  }
+  notifyTerminalStateListeners(taskID) {
+    for (const listener of this.terminalStateListeners) {
+      listener(taskID);
+    }
   }
   registerLaunch(input) {
     const now = input.now ?? Date.now();
@@ -23640,6 +24553,7 @@ class BackgroundJobBoard {
         objective: input.objective ?? existing.objective,
         state: "running",
         timedOut: false,
+        recoverableAfterLiveBusy: false,
         statusUncertain: false,
         cancellationRequested: false,
         terminalUnreconciled: false,
@@ -23650,7 +24564,9 @@ class BackgroundJobBoard {
         lastLaunchedAt: now,
         lastLiveBusyAt: now,
         lastUsedAt: now,
-        updatedAt: now
+        updatedAt: now,
+        totalErrors: existing.totalErrors ?? 0,
+        timeoutCount: existing.timeoutCount ?? 0
       };
       this.jobs.set(input.taskID, updated);
       return updated;
@@ -23663,6 +24579,7 @@ class BackgroundJobBoard {
       objective: input.objective,
       state: "running",
       timedOut: false,
+      recoverableAfterLiveBusy: false,
       statusUncertain: false,
       cancellationRequested: false,
       terminalUnreconciled: false,
@@ -23672,7 +24589,9 @@ class BackgroundJobBoard {
       lastUsedAt: now,
       updatedAt: now,
       alias: this.nextAlias(input.parentSessionID, input.agent),
-      contextFiles: []
+      contextFiles: [],
+      totalErrors: 0,
+      timeoutCount: 0
     };
     this.jobs.set(input.taskID, record);
     return record;
@@ -23691,6 +24610,7 @@ class BackgroundJobBoard {
       ...existing,
       state: input.state,
       timedOut: input.timedOut ?? false,
+      recoverableAfterLiveBusy: input.state !== "running" ? false : input.timedOut === true ? false : existing.recoverableAfterLiveBusy,
       statusUncertain: input.statusUncertain ?? false,
       terminalUnreconciled: terminal ? true : existing.terminalUnreconciled,
       updatedAt: now,
@@ -23699,10 +24619,20 @@ class BackgroundJobBoard {
       resultSummary: input.resultSummary ?? existing.resultSummary,
       lastStatusError: input.lastStatusError
     };
+    if (input.state === "completed") {
+      updated.timeoutCount = 0;
+    }
+    if (input.state === "error") {
+      updated.totalErrors = (existing.totalErrors ?? 0) + 1;
+      updated.lastErrorAt = updated.updatedAt;
+    }
+    if (input.timedOut && input.state !== "completed") {
+      updated.timeoutCount = (existing.timeoutCount ?? 0) + 1;
+    }
     this.jobs.set(input.taskID, updated);
     this.trimReusable(input.taskID);
     if (notifyTerminal)
-      this.terminalStateListener?.(input.taskID);
+      this.notifyTerminalStateListeners(input.taskID);
     return updated;
   }
   updateFromStatusOutput(output) {
@@ -23732,7 +24662,10 @@ class BackgroundJobBoard {
     const updated = {
       ...existing,
       updatedAt: now,
-      lastLiveBusyAt: now
+      lastLiveBusyAt: now,
+      timedOut: false,
+      recoverableAfterLiveBusy: existing.recoverableAfterLiveBusy || existing.timedOut,
+      statusUncertain: false
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -23773,6 +24706,7 @@ class BackgroundJobBoard {
       ...existing,
       state: "cancelled",
       timedOut: false,
+      recoverableAfterLiveBusy: false,
       statusUncertain: false,
       cancellationRequested: true,
       terminalUnreconciled: true,
@@ -23784,12 +24718,35 @@ class BackgroundJobBoard {
     };
     this.jobs.set(taskID, updated);
     if (notifyTerminal)
-      this.terminalStateListener?.(taskID);
+      this.notifyTerminalStateListeners(taskID);
     return updated;
   }
   get(taskID) {
     return this.jobs.get(taskID);
   }
+  field(taskID, key) {
+    return this.get(taskID)?.[key];
+  }
+  isRunning(taskID) {
+    const job = this.get(taskID);
+    return job?.state === "running";
+  }
+  isTerminalUnreconciled(taskID) {
+    const job = this.get(taskID);
+    return !!job?.terminalUnreconciled;
+  }
+  getResultSummary(taskID) {
+    return this.field(taskID, "resultSummary");
+  }
+  getLastLiveBusyAt(taskID) {
+    return this.field(taskID, "lastLiveBusyAt");
+  }
+  getParentSessionID(taskID) {
+    return this.field(taskID, "parentSessionID");
+  }
+  getState(taskID) {
+    return this.field(taskID, "state");
+  }
   resolve(parentSessionID, taskIDOrAlias) {
     const value = taskIDOrAlias.trim();
     return this.list(parentSessionID).find((job) => job.taskID === value || job.alias === value);
@@ -23802,6 +24759,17 @@ class BackgroundJobBoard {
       return;
     return job;
   }
+  resolveRecoverable(parentSessionID, taskIDOrAlias, agent) {
+    const job = this.resolve(parentSessionID, taskIDOrAlias);
+    if (!job)
+      return;
+    if (agent && job.agent !== agent)
+      return;
+    if (job.state !== "running" || !job.recoverableAfterLiveBusy) {
+      return;
+    }
+    return job;
+  }
   markUsed(parentSessionID, key, now = Date.now()) {
     const job = this.resolve(parentSessionID, key);
     if (!job)
@@ -23821,8 +24789,11 @@ class BackgroundJobBoard {
     for (const file of files) {
       const previous = existing.get(file.path);
       if (previous) {
-        previous.lineCount = Math.max(previous.lineCount, file.lineCount);
-        previous.lastReadAt = Math.max(previous.lastReadAt, file.lastReadAt);
+        existing.set(file.path, {
+          ...previous,
+          lineCount: Math.max(previous.lineCount, file.lineCount),
+          lastReadAt: Math.max(previous.lastReadAt, file.lastReadAt)
+        });
       } else {
         existing.set(file.path, { ...file });
       }
@@ -23841,6 +24812,14 @@ class BackgroundJobBoard {
   hasTerminalUnreconciled(parentSessionID) {
     return this.list(parentSessionID).some((job) => job.terminalUnreconciled);
   }
+  hasConvergenceSignals(taskID, threshold = 3) {
+    const job = this.jobs.get(taskID);
+    if (!job)
+      return false;
+    const errors = job.totalErrors ?? 0;
+    const timeouts = job.timeoutCount ?? 0;
+    return errors >= threshold || timeouts >= threshold;
+  }
   formatForPrompt(parentSessionID, now = Date.now()) {
     const active = this.list(parentSessionID).filter((job) => job.state === "running" || job.terminalUnreconciled);
     const reusable = this.list(parentSessionID).filter(isReusable);
@@ -23849,7 +24828,10 @@ class BackgroundJobBoard {
     return [
       "### Background Job Board",
       "SENTINEL: background-job-board-v2",
-      "Do not poll running jobs. Wait for hook-driven completion, or use cancel_task only for explicit cancellation. Reconcile terminal jobs before final response. Reuse only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
+      "Do not poll running jobs. Wait for hook-driven completion, or use cancel_task only for explicit cancellation. Reconcile terminal jobs before final response.",
+      "Completed or reconciled sessions are reusable by alias for the same specialist/context.",
+      "Timed-out running sessions are recoverable by alias for safe resume after a live busy signal.",
+      "Cancelled or errored sessions are not reusable.",
       "",
       "#### Active / Unreconciled",
       ...active.length > 0 ? active.map((job) => formatJob(job, now)) : ["- none"],
@@ -24180,13 +25162,25 @@ ${buildRetryGuidance(detected)}`;
     }
   };
 }
+// src/hooks/types.ts
+function isMessageWithParts(message) {
+  if (!message || typeof message !== "object") {
+    return false;
+  }
+  const candidate = message;
+  return !!candidate.info && typeof candidate.info === "object" && typeof candidate.info.role === "string" && Array.isArray(candidate.parts);
+}
+function isUserMessageWithParts(message) {
+  return isMessageWithParts(message) && message.info.role === "user";
+}
+
 // src/hooks/filter-available-skills/index.ts
 var AVAILABLE_SKILLS_BLOCK_REGEX = /<available_skills>\s*([\s\S]*?)\s*<\/available_skills>/g;
 var SKILL_NAME_REGEX = /<name>([^<]+)<\/name>/;
 function getCurrentAgent(messages) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
-    if (message.info.role === "user") {
+    if (isUserMessageWithParts(message)) {
       return message.info.agent ?? "orchestrator";
     }
   }
@@ -24243,7 +25237,7 @@ function createFilterAvailableSkillsHook(_ctx, config) {
   };
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output;
+      const messages = (Array.isArray(output.messages) ? output.messages : []).filter(isMessageWithParts);
       if (messages.length === 0) {
         return;
       }
@@ -24274,7 +25268,11 @@ var RATE_LIMIT_PATTERNS = [
   /resource.?exhausted/i,
   /insufficient.?(quota|balance)/i,
   /high concurrency/i,
-  /reduce concurrency/i
+  /reduce concurrency/i,
+  /service unavailable/i,
+  /monthly usage limit/i,
+  /5-hour usage limit/i,
+  /weekly usage limit/i
 ];
 function isRateLimitError(error) {
   if (!error || typeof error !== "object")
@@ -24300,6 +25298,7 @@ class ForegroundFallbackManager {
   sessionTried = new Map;
   inProgress = new Set;
   lastTrigger = new Map;
+  lastTriggerModel = new Map;
   constructor(client, chains, enabled) {
     this.client = client;
     this.chains = chains;
@@ -24339,9 +25338,9 @@ class ForegroundFallbackManager {
       }
       case "session.status": {
         const props = event.properties;
-        if (!props?.sessionID || props.status?.type !== "retry")
+        if (!props?.sessionID || !props.status?.message)
           break;
-        const msg = props.status.message?.toLowerCase() ?? "";
+        const msg = props.status.message.toLowerCase();
         if (msg.includes("rate limit") || msg.includes("usage limit") || msg.includes("usage exceeded") || msg.includes("quota exceeded") || msg.includes("exceededbudget") || msg.includes("over budget") || msg.includes("insufficient") || msg.includes("high concurrency") || msg.includes("reduce concurrency")) {
           await this.tryFallback(props.sessionID);
         }
@@ -24363,6 +25362,7 @@ class ForegroundFallbackManager {
           this.sessionTried.delete(id);
           this.inProgress.delete(id);
           this.lastTrigger.delete(id);
+          this.lastTriggerModel.delete(id);
         }
         break;
       }
@@ -24374,12 +25374,17 @@ class ForegroundFallbackManager {
     if (this.inProgress.has(sessionID))
       return;
     const now = Date.now();
-    if (now - (this.lastTrigger.get(sessionID) ?? 0) < DEDUP_WINDOW_MS)
+    const curModel = this.sessionModel.get(sessionID);
+    const modelChanged = this.lastTriggerModel.has(sessionID) && this.lastTriggerModel.get(sessionID) !== curModel;
+    if (!modelChanged && now - (this.lastTrigger.get(sessionID) ?? 0) < DEDUP_WINDOW_MS)
       return;
     this.lastTrigger.set(sessionID, now);
+    if (curModel !== undefined) {
+      this.lastTriggerModel.set(sessionID, curModel);
+    }
     this.inProgress.add(sessionID);
     try {
-      const currentModel = this.sessionModel.get(sessionID);
+      let currentModel = this.sessionModel.get(sessionID);
       const agentName = this.sessionAgent.get(sessionID);
       const chain = this.resolveChain(agentName, currentModel);
       if (!chain.length) {
@@ -24389,20 +25394,42 @@ class ForegroundFallbackManager {
         });
         return;
       }
+      if (!currentModel && agentName && chain.length > 0) {
+        currentModel = chain[0];
+      }
       if (!this.sessionTried.has(sessionID)) {
         this.sessionTried.set(sessionID, new Set);
       }
-      const tried = this.sessionTried.get(sessionID);
+      let tried = this.sessionTried.get(sessionID);
       if (currentModel)
         tried.add(currentModel);
-      const nextModel = chain.find((m) => !tried.has(m));
+      let nextModel = chain.find((m) => !tried.has(m));
       if (!nextModel) {
-        log("[foreground-fallback] fallback chain exhausted", {
-          sessionID,
-          agentName,
-          tried: [...tried]
-        });
-        return;
+        if (chain.length > 1) {
+          const primary = chain[0];
+          const stickyFallback = chain[chain.length - 1];
+          log("[foreground-fallback] resetting tried set for re-fallback", {
+            sessionID,
+            agentName,
+            currentModel,
+            prevTried: [...tried],
+            nextModel: stickyFallback
+          });
+          tried = new Set;
+          if (primary)
+            tried.add(primary);
+          if (currentModel && currentModel !== primary)
+            tried.add(currentModel);
+          this.sessionTried.set(sessionID, tried);
+          nextModel = stickyFallback;
+        } else {
+          log("[foreground-fallback] fallback chain exhausted", {
+            sessionID,
+            agentName,
+            tried: [...tried]
+          });
+          return;
+        }
       }
       tried.add(nextModel);
       const ref = parseModelReference(nextModel);
@@ -24417,7 +25444,7 @@ class ForegroundFallbackManager {
         path: { id: sessionID }
       });
       const messages = result.data ?? [];
-      const lastUser = [...messages].reverse().find((m) => m.info.role === "user");
+      const lastUser = [...messages].reverse().find(isUserMessageWithParts);
       if (!lastUser) {
         log("[foreground-fallback] no user message found", { sessionID });
         return;
@@ -24458,7 +25485,11 @@ class ForegroundFallbackManager {
   }
   resolveChain(agentName, currentModel) {
     if (agentName) {
-      return this.chains[agentName] ?? [];
+      const chain = this.chains[agentName];
+      if (chain)
+        return chain;
+      if (ALL_AGENT_NAMES.includes(agentName))
+        return [];
     }
     if (currentModel) {
       for (const chain of Object.values(this.chains)) {
@@ -24480,17 +25511,17 @@ class ForegroundFallbackManager {
   }
 }
 // src/hooks/image-hook.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
   rmdirSync,
   statSync as statSync4,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync5
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename as basename2, extname, join as join11 } from "node:path";
+import { basename as basename3, extname, join as join11 } from "node:path";
 var lastCleanupByDir = new Map;
 var CLEANUP_INTERVAL = 10 * 60 * 1000;
 function isImagePart(p) {
@@ -24544,7 +25575,7 @@ function cleanupAllSessions(saveDir) {
       } else {
         try {
           if (now - statSync4(fp).mtimeMs > maxAge)
-            unlinkSync2(fp);
+            unlinkSync3(fp);
         } catch {}
       }
     }
@@ -24558,7 +25589,7 @@ function cleanupAllSessions(saveDir) {
         const fp = join11(dir, f);
         try {
           if (now - statSync4(fp).mtimeMs > maxAge) {
-            unlinkSync2(fp);
+            unlinkSync3(fp);
           } else {
             allRemoved = false;
           }
@@ -24576,7 +25607,7 @@ function cleanupAllSessions(saveDir) {
 }
 function writeUniqueFile(dir, name, data, log2) {
   const ext = extname(name);
-  const base = basename2(name, ext) || name;
+  const base = basename3(name, ext) || name;
   let candidate = join11(dir, name);
   if (existsSync7(candidate)) {
     return candidate;
@@ -24585,7 +25616,7 @@ function writeUniqueFile(dir, name, data, log2) {
   const MAX_ATTEMPTS = 1000;
   for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
     try {
-      writeFileSync5(candidate, data, { flag: "wx" });
+      writeFileSync6(candidate, data, { flag: "wx" });
       return candidate;
     } catch (e) {
       if (e instanceof Error && e.code === "EEXIST") {
@@ -24607,7 +25638,7 @@ function processImageAttachments(args) {
     return;
   const messagesWithImages = [];
   for (const msg of messages) {
-    if (msg.info.role !== "user")
+    if (!isUserMessageWithParts(msg))
       continue;
     const imageParts = msg.parts.filter(isImagePart);
     if (imageParts.length > 0) {
@@ -24624,7 +25655,7 @@ function processImageAttachments(args) {
   try {
     mkdirSync5(saveDir, { recursive: true });
     if (!existsSync7(gitignorePath))
-      writeFileSync5(gitignorePath, `*
+      writeFileSync6(gitignorePath, `*
 `);
   } catch (e) {
     log2(`[image-hook] failed to create image directory: ${e}`);
@@ -24645,7 +25676,7 @@ function processImageAttachments(args) {
       if (url) {
         const decoded = decodeDataUrl(url);
         if (decoded) {
-          const hash = createHash2("sha1").update(decoded.data).digest("hex").slice(0, 8);
+          const hash = createHash3("sha1").update(decoded.data).digest("hex").slice(0, 8);
           const sanitizedFilename = filename ? sanitizeFilename(filename) : undefined;
           const baseName = sanitizedFilename ? sanitizedFilename.replace(/\.[^.]+$/, "") || "image" : "image";
           const ext = sanitizedFilename ? extname(sanitizedFilename) || extFromMime(decoded.mime) : extFromMime(decoded.mime);
@@ -24717,17 +25748,84 @@ ${JSON_ERROR_REMINDER}`;
     }
   };
 }
+// src/hooks/loop-command/index.ts
+var COMMAND_NAME2 = "loop";
+function historyDir() {
+  const shortID = Math.random().toString(36).slice(2, 8);
+  const timestamp = Date.now().toString(36);
+  return `.opencode/loop-history/loop-${timestamp}-${shortID}`;
+}
+function activationPrompt2(text) {
+  const dir = historyDir();
+  return [
+    "The user ran `/loop`. From the text below, extract: goal, successCriteria, maxAttempts.",
+    "",
+    "If ANY are missing or unclear - push back and ask the user to clarify.",
+    "Do not assume or guess. All three must be explicit.",
+    "",
+    "Once all three are clear, run the loop:",
+    "",
+    text,
+    "",
+    "For each attempt:",
+    `1. Read \`${dir}/\` for prior results`,
+    "2. Dispatch @fixer with the goal",
+    "3. Verify per the successCriteria",
+    `4. Write result to \`${dir}/history-{NNN}.md\` (PASS/FAIL + reason)`,
+    "5. PASS -> stop. FAIL under maxAttempts -> retry. FAIL at max -> escalate."
+  ].join(`
+`);
+}
+function helpPrompt() {
+  return [
+    "Usage: `/loop <description>`",
+    "",
+    "Describe what to accomplish, what success looks like, and how many tries.",
+    "",
+    "Examples:",
+    "  `/loop fix typescript errors until typecheck passes, max 3 tries`",
+    "  `/loop improve api performance until response under 500ms, try 5 times`",
+    "  `/loop refactor auth module, tests must pass, 4 attempts max`"
+  ].join(`
+`);
+}
+function createLoopCommandHook() {
+  return {
+    registerCommand: (opencodeConfig) => {
+      const cfg = opencodeConfig.command;
+      if (cfg?.[COMMAND_NAME2])
+        return;
+      if (!opencodeConfig.command)
+        opencodeConfig.command = {};
+      opencodeConfig.command[COMMAND_NAME2] = {
+        template: "Run an automated execute-verify loop",
+        description: "Dispatch fixer, verify, iterate with file-based history on disk."
+      };
+    },
+    handleCommandExecuteBefore: async (input, output) => {
+      if (input.command !== COMMAND_NAME2)
+        return;
+      output.parts.length = 0;
+      const args = input.arguments.trim();
+      if (!args) {
+        output.parts.push(createInternalAgentTextPart(helpPrompt()));
+        return;
+      }
+      output.parts.push({ type: "text", text: activationPrompt2(args) });
+    }
+  };
+}
 // src/hooks/phase-reminder/index.ts
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output;
+      const messages = Array.isArray(output.messages) ? output.messages : [];
       if (messages.length === 0) {
         return;
       }
       let lastUserMessageIndex = -1;
       for (let i = messages.length - 1;i >= 0; i--) {
-        if (messages[i].info.role === "user") {
+        if (isUserMessageWithParts(messages[i])) {
           lastUserMessageIndex = i;
           break;
         }
@@ -24736,6 +25834,9 @@ function createPhaseReminderHook() {
         return;
       }
       const lastUserMessage = messages[lastUserMessageIndex];
+      if (!isUserMessageWithParts(lastUserMessage)) {
+        return;
+      }
       const agent = lastUserMessage.info.agent;
       if (agent && agent !== "orchestrator") {
         return;
@@ -24785,12 +25886,22 @@ ${PHASE_REMINDER}`;
   };
 }
 // src/hooks/reflect/index.ts
-var COMMAND_NAME2 = "reflect";
-function activationPrompt2(focus) {
+var COMMAND_NAME3 = "reflect";
+function activationPrompt3(focus, isSessionMode = false, lastN = 50) {
   const focusBlock = focus ? ["Focus:", focus] : [
     "Focus:",
-    "Review recent work broadly and identify repeated workflow friction worth improving."
+    isSessionMode ? "Analyze recent sessions to find repeated patterns, friction, and improvement opportunities." : "Review recent work broadly and identify repeated workflow friction worth improving."
   ];
+  const modeBlock = isSessionMode ? [
+    "",
+    "Session Reflection Mode:",
+    `- Analyze the last ${lastN} sessions (use --last N to adjust)`,
+    "- Extract session IDs from OpenCode logs",
+    "- Load session content from SQLite database",
+    "- Analyze each session for patterns and friction",
+    "- Aggregate findings across all sessions",
+    "- Report with scope (global/cross-repo/project-specific), confidence, and impact"
+  ] : [];
   return [
     "Use the reflect skill for this request.",
     "",
@@ -24802,6 +25913,7 @@ function activationPrompt2(focus) {
     "- treat creating nothing as a valid result when evidence is weak;",
     "- ask before changing prompts, skills, commands, agents, MCP access, or config unless the user explicitly requested the exact edit;",
     "- return a compact report with findings, recommended changes, skipped candidates, and items needing more evidence.",
+    ...modeBlock,
     "",
     ...focusBlock
   ].join(`
@@ -24812,32 +25924,155 @@ function createReflectCommandHook() {
   return {
     registerCommand: (opencodeConfig) => {
       const commandConfig = opencodeConfig.command;
-      if (commandConfig?.[COMMAND_NAME2]) {
+      if (commandConfig?.[COMMAND_NAME3]) {
         shouldHandleCommand = false;
         return;
       }
       if (!opencodeConfig.command)
         opencodeConfig.command = {};
-      opencodeConfig.command[COMMAND_NAME2] = {
+      opencodeConfig.command[COMMAND_NAME3] = {
         template: "Review repeated work and suggest workflow improvements",
         description: "Use reflect to learn from repeated workflows and suggest reusable improvements"
       };
       shouldHandleCommand = true;
     },
     handleCommandExecuteBefore: async (input, output) => {
-      if (input.command !== COMMAND_NAME2 || !shouldHandleCommand)
+      if (input.command !== COMMAND_NAME3 || !shouldHandleCommand)
         return;
+      const args = input.arguments.trim();
+      const isSessionMode = args.includes("--sessions");
+      const lastMatch = args.match(/--last\s+(\d+)/);
+      const last = lastMatch ? Math.min(parseInt(lastMatch[1], 10), 100) : 50;
+      const focus = args.replace(/--sessions/g, "").replace(/--last\s+\d+/g, "").trim();
       output.parts.length = 0;
       output.parts.push({
         type: "text",
-        text: activationPrompt2(input.arguments.trim())
+        text: activationPrompt3(focus, isSessionMode, last)
       });
     }
   };
 }
-// src/hooks/task-session-manager/index.ts
-import path12 from "node:path";
+// src/hooks/task-session-manager/pending-call-tracker.ts
 var MAX_PENDING_TASK_CALLS = 100;
+function createPendingCallTracker() {
+  const pendingCalls = new Map;
+  let anonymousPendingCallId = 0;
+  return {
+    add(call) {
+      pendingCalls.delete(call.callId);
+      pendingCalls.set(call.callId, call);
+      while (pendingCalls.size > MAX_PENDING_TASK_CALLS) {
+        const firstKey = pendingCalls.keys().next().value;
+        if (firstKey === undefined)
+          break;
+        pendingCalls.delete(firstKey);
+      }
+    },
+    take(callId, parentSessionId) {
+      if (!callId && parentSessionId) {
+        for (const id of pendingCalls.keys()) {
+          const call = pendingCalls.get(id);
+          if (call && call.parentSessionId === parentSessionId) {
+            callId = id;
+            break;
+          }
+        }
+      }
+      if (!callId)
+        return;
+      const pending = pendingCalls.get(callId);
+      pendingCalls.delete(callId);
+      return pending;
+    },
+    clearSession(sessionId) {
+      for (const [callId, pending] of pendingCalls.entries()) {
+        if (pending.parentSessionId === sessionId) {
+          pendingCalls.delete(callId);
+        }
+      }
+    },
+    pendingCallId(sessionID, callID) {
+      return callID ?? `${sessionID ?? "unknown"}:anonymous-${++anonymousPendingCallId}`;
+    }
+  };
+}
+
+// src/hooks/task-session-manager/task-context-tracker.ts
+import path12 from "node:path";
+function createTaskContextTracker() {
+  const contextByTask = new Map;
+  const pendingManagedTaskIds = new Set;
+  return {
+    pendingManagedTaskIds,
+    addContext(taskId, files) {
+      if (files.length === 0)
+        return;
+      let context = contextByTask.get(taskId);
+      if (!context) {
+        context = new Map;
+        contextByTask.set(taskId, context);
+      }
+      for (const file of files) {
+        const pending = context.get(file.path) ?? {
+          path: file.path,
+          lines: new Set,
+          lastReadAt: file.lastReadAt
+        };
+        for (const line of file.lineNumbers ?? []) {
+          pending.lines.add(line);
+        }
+        pending.lastReadAt = Math.max(pending.lastReadAt, file.lastReadAt);
+        context.set(file.path, pending);
+      }
+    },
+    prune(backgroundJobBoard) {
+      const remembered = backgroundJobBoard.taskIDs();
+      for (const taskId of contextByTask.keys()) {
+        if (!pendingManagedTaskIds.has(taskId) && !remembered.has(taskId)) {
+          contextByTask.delete(taskId);
+        }
+      }
+    },
+    clearSession(sessionId) {
+      contextByTask.delete(sessionId);
+      pendingManagedTaskIds.delete(sessionId);
+    },
+    contextFilesForPrompt(taskId) {
+      const context = contextByTask.get(taskId);
+      if (!context)
+        return [];
+      return [...context.values()].map((file) => ({
+        path: file.path,
+        lineCount: file.lines.size,
+        lastReadAt: file.lastReadAt
+      }));
+    }
+  };
+}
+function extractReadFiles(root, output) {
+  if (typeof output.output !== "string")
+    return [];
+  const extractPath = /<path>([^<]+)<\/path>/.exec(output.output)?.[1];
+  if (!extractPath)
+    return [];
+  const relative2 = path12.relative(root, extractPath);
+  const normalized = !relative2 || relative2.startsWith("..") || path12.isAbsolute(relative2) ? extractPath : relative2;
+  const matchedLines = new Set;
+  for (const match of output.output.matchAll(/^([0-9]+):/gm)) {
+    matchedLines.add(Number(match[1]));
+  }
+  const lineNumbers = [...matchedLines];
+  return [
+    {
+      path: normalized,
+      lineCount: lineNumbers.length,
+      lineNumbers,
+      lastReadAt: Date.now()
+    }
+  ];
+}
+
+// src/hooks/task-session-manager/index.ts
 var BACKGROUND_JOB_BOARD_SENTINEL = "SENTINEL: background-job-board-v2";
 var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
 var BACKGROUND_COMPLETION_FAILED = /^Background task failed: /;
@@ -24868,98 +26103,21 @@ function createOccurrenceId(part, message, partIndex) {
   const hash = djb2Hash(`${sessionID}:${content}`);
   return `anon:${hash}`;
 }
-function extractPath(output) {
-  return /<path>([^<]+)<\/path>/.exec(output)?.[1];
-}
 function extractTaskSummary(output) {
   const summary = /<summary>\s*([\s\S]*?)\s*<\/summary>/i.exec(output)?.[1];
   return summary?.trim() || undefined;
 }
-function normalizePath(root, file) {
-  const relative = path12.relative(root, file);
-  if (!relative || relative.startsWith("..") || path12.isAbsolute(relative)) {
-    return file;
-  }
-  return relative;
-}
-function extractReadFiles(root, output) {
-  if (typeof output.output !== "string")
-    return [];
-  const file = extractPath(output.output);
-  if (!file)
-    return [];
-  return [
-    {
-      path: normalizePath(root, file),
-      lineCount: countReadLines(output.output).length,
-      lineNumbers: countReadLines(output.output),
-      lastReadAt: Date.now()
-    }
-  ];
-}
-function countReadLines(output) {
-  const lines = new Set;
-  for (const match of output.matchAll(/^([0-9]+):/gm)) {
-    lines.add(Number(match[1]));
-  }
-  return [...lines];
-}
 function createTaskSessionManagerHook(_ctx, options) {
   const backgroundJobBoard = options.backgroundJobBoard ?? new BackgroundJobBoard({
     maxReusablePerAgent: options.maxSessionsPerAgent,
     readContextMinLines: options.readContextMinLines,
     readContextMaxFiles: options.readContextMaxFiles
   });
-  const pendingCalls = new Map;
-  const pendingCallOrder = [];
-  const contextByTask = new Map;
-  const pendingManagedTaskIds = new Set;
-  const terminalJobsInjectedByParent = new Map;
+  const pendingCallTracker = createPendingCallTracker();
+  const taskContextTracker = createTaskContextTracker();
   const processedInjectedCompletions = new Set;
   const processedInjectedCompletionOrder = [];
-  let anonymousPendingCallId = 0;
-  function addTaskContext(taskId, files) {
-    if (files.length === 0)
-      return;
-    let context = contextByTask.get(taskId);
-    if (!context) {
-      context = new Map;
-      contextByTask.set(taskId, context);
-    }
-    for (const file of files) {
-      const pending = context.get(file.path) ?? {
-        path: file.path,
-        lines: new Set,
-        lastReadAt: file.lastReadAt
-      };
-      for (const line of file.lineNumbers ?? []) {
-        pending.lines.add(line);
-      }
-      pending.lastReadAt = Math.max(pending.lastReadAt, file.lastReadAt);
-      context.set(file.path, pending);
-    }
-    backgroundJobBoard.addContext(taskId, contextFilesForPrompt(context));
-  }
-  function contextFilesForPrompt(context) {
-    if (!context)
-      return [];
-    return [...context.values()].map((file) => ({
-      path: file.path,
-      lineCount: file.lines.size,
-      lastReadAt: file.lastReadAt
-    }));
-  }
-  function canTrackTaskContext(taskId) {
-    return pendingManagedTaskIds.has(taskId) || backgroundJobBoard.taskIDs().has(taskId);
-  }
-  function pruneContext() {
-    const remembered = backgroundJobBoard.taskIDs();
-    for (const taskId of contextByTask.keys()) {
-      if (!pendingManagedTaskIds.has(taskId) && !remembered.has(taskId)) {
-        contextByTask.delete(taskId);
-      }
-    }
-  }
+  const terminalJobsInjectedByParent = new Map;
   function updateBackgroundJobFromOutput(output) {
     if (typeof output !== "string")
       return;
@@ -24977,7 +26135,8 @@ function createTaskSessionManagerHook(_ctx, options) {
       log("[task-session-manager] suppressed late cancelled task error", {
         taskID: status.taskID,
         alias: existing?.alias,
-        state: existing?.state,
+        parsedState: status.state,
+        boardState: existing?.state,
         terminalState: existing?.terminalState,
         result: status.result
       });
@@ -25004,10 +26163,10 @@ function createTaskSessionManagerHook(_ctx, options) {
       terminalUnreconciled: updated.terminalUnreconciled,
       timedOut: updated.timedOut
     });
-    if (updated.terminalUnreconciled) {
-      pendingManagedTaskIds.delete(updated.taskID);
-      backgroundJobBoard.addContext(updated.taskID, contextFilesForPrompt(contextByTask.get(updated.taskID)));
-      pruneContext();
+    if (backgroundJobBoard.isTerminalUnreconciled(updated.taskID)) {
+      taskContextTracker.pendingManagedTaskIds.delete(updated.taskID);
+      backgroundJobBoard.addContext(updated.taskID, taskContextTracker.contextFilesForPrompt(updated.taskID));
+      taskContextTracker.prune(backgroundJobBoard);
     }
     return updated;
   }
@@ -25031,11 +26190,12 @@ function createTaskSessionManagerHook(_ctx, options) {
     const occurrenceId = createOccurrenceId(part, message, partIndex);
     const existing = backgroundJobBoard.get(status.taskID);
     if (isFailed && isLateCancelledTaskError(existing, status.state)) {
-      part.text = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+      part.text = formatCancelledTaskStatusOutput(status.taskID, backgroundJobBoard.getResultSummary(status.taskID));
       log("[task-session-manager] normalized late cancelled injected failure", {
         taskID: status.taskID,
         alias: existing?.alias,
-        state: existing?.state,
+        parsedState: status.state,
+        boardState: existing?.state,
         terminalState: existing?.terminalState,
         result: status.result
       });
@@ -25075,41 +26235,6 @@ function createTaskSessionManagerHook(_ctx, options) {
     const firstLine = output.split(/\r?\n/, 1)[0]?.trim().toLowerCase() ?? "";
     return firstLine.startsWith("[error]") && firstLine.includes("session") && (firstLine.includes("not found") || firstLine.includes("no session"));
   }
-  function pendingCallId(input) {
-    return input.callID ?? `${input.sessionID ?? "unknown"}:anonymous-${++anonymousPendingCallId}`;
-  }
-  function rememberPendingCall(call) {
-    const existingIndex = pendingCallOrder.indexOf(call.callId);
-    if (existingIndex >= 0) {
-      pendingCallOrder.splice(existingIndex, 1);
-    }
-    pendingCalls.set(call.callId, call);
-    pendingCallOrder.push(call.callId);
-    while (pendingCallOrder.length > MAX_PENDING_TASK_CALLS) {
-      const evictedCallId = pendingCallOrder.shift();
-      if (!evictedCallId) {
-        break;
-      }
-      pendingCalls.delete(evictedCallId);
-    }
-  }
-  function takePendingCall(callId, parentSessionId) {
-    const resolvedCallId = callId ?? firstPendingCallForParent(parentSessionId);
-    if (!resolvedCallId)
-      return;
-    const pending = pendingCalls.get(resolvedCallId);
-    pendingCalls.delete(resolvedCallId);
-    const orderIndex = pendingCallOrder.indexOf(resolvedCallId);
-    if (orderIndex >= 0) {
-      pendingCallOrder.splice(orderIndex, 1);
-    }
-    return pending;
-  }
-  function firstPendingCallForParent(parentSessionId) {
-    if (!parentSessionId)
-      return;
-    return pendingCallOrder.find((callId) => pendingCalls.get(callId)?.parentSessionId === parentSessionId);
-  }
   function rememberInjectedTerminalJobs(parentSessionID) {
     const taskIDs = backgroundJobBoard.list(parentSessionID).filter((job) => job.terminalUnreconciled).map((job) => job.taskID);
     if (taskIDs.length === 0)
@@ -25161,45 +26286,50 @@ function createTaskSessionManagerHook(_ctx, options) {
         agentType
       });
       const pendingCall = {
-        callId: pendingCallId({
-          callID: input.callID,
-          sessionID: input.sessionID
-        }),
+        callId: pendingCallTracker.pendingCallId(input.sessionID, input.callID),
         parentSessionId: input.sessionID,
         agentType,
         label
       };
-      rememberPendingCall(pendingCall);
+      pendingCallTracker.add(pendingCall);
       if (typeof args.task_id !== "string" || args.task_id.trim() === "") {
         return;
       }
       const requested = args.task_id.trim();
-      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, agentType);
+      const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, agentType) ?? backgroundJobBoard.resolveRecoverable(input.sessionID, requested, agentType);
       if (!remembered) {
+        const knownManagedTask = backgroundJobBoard.resolve(input.sessionID, requested);
+        if (knownManagedTask) {
+          delete args.task_id;
+          return;
+        }
         if (RAW_SESSION_ID_PATTERN.test(requested)) {
           pendingCall.resumedTaskId = requested;
-          rememberPendingCall(pendingCall);
+          pendingCallTracker.add(pendingCall);
           return;
         }
         delete args.task_id;
         return;
       }
       args.task_id = remembered.taskID;
-      pendingManagedTaskIds.add(remembered.taskID);
+      taskContextTracker.pendingManagedTaskIds.add(remembered.taskID);
       backgroundJobBoard.markUsed(input.sessionID, remembered.taskID);
       pendingCall.resumedTaskId = remembered.taskID;
-      rememberPendingCall(pendingCall);
+      pendingCallTracker.add(pendingCall);
     },
     "tool.execute.after": async (input, output) => {
       if (input.tool.toLowerCase() === "read") {
-        if (input.sessionID && canTrackTaskContext(input.sessionID)) {
-          addTaskContext(input.sessionID, extractReadFiles(_ctx.directory, output));
+        if (input.sessionID) {
+          const canTrack = taskContextTracker.pendingManagedTaskIds.has(input.sessionID) || backgroundJobBoard.taskIDs().has(input.sessionID);
+          if (canTrack) {
+            taskContextTracker.addContext(input.sessionID, extractReadFiles(_ctx.directory, output));
+          }
         }
         return;
       }
       if (input.tool.toLowerCase() !== "task")
         return;
-      const pending = takePendingCall(input.callID, input.sessionID);
+      const pending = pendingCallTracker.take(input.callID, input.sessionID);
       if (!pending || typeof output.output !== "string")
         return;
       const launch = parseTaskLaunchOutput(output.output);
@@ -25219,8 +26349,8 @@ function createTaskSessionManagerHook(_ctx, options) {
           description: record.description,
           state: record.state
         });
-        backgroundJobBoard.addContext(launch.taskID, contextFilesForPrompt(contextByTask.get(launch.taskID)));
-        pendingManagedTaskIds.add(launch.taskID);
+        taskContextTracker.pendingManagedTaskIds.add(launch.taskID);
+        backgroundJobBoard.addContext(launch.taskID, taskContextTracker.contextFilesForPrompt(launch.taskID));
         return;
       }
       normalizeLateCancelledTaskOutput(output);
@@ -25250,10 +26380,9 @@ function createTaskSessionManagerHook(_ctx, options) {
         if (pending.resumedTaskId && pending.resumedTaskId !== status.taskID) {
           backgroundJobBoard.drop(pending.resumedTaskId);
         }
-        pendingManagedTaskIds.delete(status.taskID);
-        const contextFiles2 = contextFilesForPrompt(contextByTask.get(status.taskID));
-        backgroundJobBoard.addContext(status.taskID, contextFiles2);
-        pruneContext();
+        taskContextTracker.pendingManagedTaskIds.delete(status.taskID);
+        backgroundJobBoard.addContext(status.taskID, taskContextTracker.contextFilesForPrompt(status.taskID));
+        taskContextTracker.prune(backgroundJobBoard);
         return;
       }
       const taskId = parseTaskIdFromTaskOutput(output.output);
@@ -25266,14 +26395,14 @@ function createTaskSessionManagerHook(_ctx, options) {
       if (pending.resumedTaskId && pending.resumedTaskId !== taskId) {
         backgroundJobBoard.drop(pending.resumedTaskId);
       }
-      pendingManagedTaskIds.delete(taskId);
-      const contextFiles = contextFilesForPrompt(contextByTask.get(taskId));
-      backgroundJobBoard.addContext(taskId, contextFiles);
-      pruneContext();
+      taskContextTracker.pendingManagedTaskIds.delete(taskId);
+      backgroundJobBoard.addContext(taskId, taskContextTracker.contextFilesForPrompt(taskId));
+      taskContextTracker.prune(backgroundJobBoard);
     },
     "experimental.chat.messages.transform": async (_input, output) => {
-      for (const [messageIndex, message] of output.messages.entries()) {
-        if (message.info.role !== "user")
+      const messages = Array.isArray(output.messages) ? output.messages : [];
+      for (const [messageIndex, message] of messages.entries()) {
+        if (!isUserMessageWithParts(message))
           continue;
         if (message.info.agent && message.info.agent !== "orchestrator") {
           continue;
@@ -25285,9 +26414,9 @@ function createTaskSessionManagerHook(_ctx, options) {
           updateFromInjectedCompletion(part, message, messageIndex, partIndex);
         }
       }
-      for (let i = output.messages.length - 1;i >= 0; i -= 1) {
-        const message = output.messages[i];
-        if (message.info.role !== "user")
+      for (let i = messages.length - 1;i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!isUserMessageWithParts(message))
           continue;
         if (message.info.agent && message.info.agent !== "orchestrator")
           return;
@@ -25323,7 +26452,7 @@ function createTaskSessionManagerHook(_ctx, options) {
           managesParent: info?.parentID ? options.shouldManageSession(info.parentID) : false
         });
         if (info?.id && info.parentID && options.shouldManageSession(info.parentID)) {
-          pendingManagedTaskIds.add(info.id);
+          taskContextTracker.pendingManagedTaskIds.add(info.id);
         }
         return;
       }
@@ -25342,7 +26471,10 @@ function createTaskSessionManagerHook(_ctx, options) {
       if (input.event.type === "session.error") {
         const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
         if (sessionId2 && options.shouldManageSession(sessionId2)) {
-          terminalJobsInjectedByParent.delete(sessionId2);
+          const props = input.event.properties;
+          if (!props?.error || !isRateLimitError(props.error)) {
+            terminalJobsInjectedByParent.delete(sessionId2);
+          }
         }
         return;
       }
@@ -25356,9 +26488,7 @@ function createTaskSessionManagerHook(_ctx, options) {
             previousState: before.state,
             previousTerminalState: before.terminalState,
             terminalUnreconciled: before.terminalUnreconciled,
-            resultSummary: before.resultSummary,
-            updatedState: updated?.state,
-            updatedCancellationRequested: updated?.cancellationRequested
+            resultSummary: before.resultSummary
           });
         }
         log("[task-session-manager] busy/status busy observed", {
@@ -25366,10 +26496,10 @@ function createTaskSessionManagerHook(_ctx, options) {
           managesSession: sessionId2 ? options.shouldManageSession(sessionId2) : false,
           previousState: before?.state,
           previousTerminalState: before?.terminalState,
-          previousCancellationRequested: before?.cancellationRequested,
+          previousCancellationRequested: before?.cancellationRequested ?? false,
           previousLastLiveBusyAt: before?.lastLiveBusyAt,
           updatedState: updated?.state,
-          updatedCancellationRequested: updated?.cancellationRequested,
+          updatedCancellationRequested: updated?.cancellationRequested ?? false,
           updatedLastLiveBusyAt: updated?.lastLiveBusyAt
         });
         return;
@@ -25381,26 +26511,23 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       log("[task-session-manager] session.deleted observed; clearing job state", {
         sessionID: sessionId,
-        deletedJob: backgroundJobBoard.get(sessionId) ? {
-          state: backgroundJobBoard.get(sessionId)?.state,
-          parentSessionID: backgroundJobBoard.get(sessionId)?.parentSessionID,
-          alias: backgroundJobBoard.get(sessionId)?.alias
-        } : undefined,
+        deletedJob: (() => {
+          const record = backgroundJobBoard.get(sessionId);
+          return record ? {
+            state: record.state,
+            parentSessionID: record.parentSessionID,
+            alias: record.alias
+          } : undefined;
+        })(),
         childJobCount: backgroundJobBoard.list(sessionId).length,
         managesSession: options.shouldManageSession(sessionId)
       });
       backgroundJobBoard.drop(sessionId);
       backgroundJobBoard.clearParent(sessionId);
       terminalJobsInjectedByParent.delete(sessionId);
-      contextByTask.delete(sessionId);
-      pendingManagedTaskIds.delete(sessionId);
-      pruneContext();
-      for (const [callId, pending] of pendingCalls.entries()) {
-        if (pending.parentSessionId !== sessionId) {
-          continue;
-        }
-        takePendingCall(callId);
-      }
+      taskContextTracker.clearSession(sessionId);
+      taskContextTracker.prune(backgroundJobBoard);
+      pendingCallTracker.clearSession(sessionId);
     }
   };
   function normalizeLateCancelledTaskOutput(output) {
@@ -25419,7 +26546,7 @@ function createTaskSessionManagerHook(_ctx, options) {
       terminalState: existing?.terminalState,
       result: status.result
     });
-    output.output = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+    output.output = formatCancelledTaskStatusOutput(status.taskID, backgroundJobBoard.getResultSummary(status.taskID));
     if (isRecord(output) && isRecord(output.metadata)) {
       output.metadata.state = "cancelled";
     }
@@ -25443,17 +26570,14 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
   ].join(`
 `);
 }
-// src/interview/manager.ts
-import path16 from "node:path";
-
 // src/interview/dashboard.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import * as fsSync2 from "node:fs";
 import fs7 from "node:fs/promises";
 import {
   createServer
 } from "node:http";
-import os4 from "node:os";
+import os5 from "node:os";
 import path14 from "node:path";
 import { URL as URL2 } from "node:url";
 
@@ -26035,8 +27159,8 @@ function renderDashboardPage(interviews, files, outputFolder) {
         <p class="muted">${totalCount} item${totalCount === 1 ? "" : "s"}</p>
       </div>
       <div class="info-box">
-        <strong>Interviews</strong> — live sessions and recovered files. State is pushed from OpenCode sessions to this dashboard.<br>
-        <strong>Files without session</strong> — <code>.md</code> files in <code>${escapeHtml(outputFolder)}</code> with no frontmatter. Resume with <code>/interview &lt;name&gt;</code>.
+        <strong>Interviews</strong> - live sessions and recovered files. State is pushed from OpenCode sessions to this dashboard.<br>
+        <strong>Files without session</strong> - <code>.md</code> files in <code>${escapeHtml(outputFolder)}</code> with no frontmatter. Resume with <code>/interview &lt;name&gt;</code>.
       </div>
       <details style="margin-bottom:24px">
         <summary style="cursor:pointer;font-size:13px;color:rgba(255,255,255,0.4);user-select:none">Settings</summary>
@@ -26064,7 +27188,7 @@ function renderDashboardPage(interviews, files, outputFolder) {
       ${fileSection}
       <div class="footer">OH MY OPENCODE SLIM</div>
     </div>
-    <div class="update-banner" id="updateBanner">Dashboard updated — tap to refresh</div>
+    <div class="update-banner" id="updateBanner">Dashboard updated - tap to refresh</div>
     <script>
       ${clipboardHelperJs()}
       document.querySelectorAll('.copy-btn').forEach(btn => {
@@ -26731,7 +27855,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
     </div>
 
     <div class="chat-panel" id="chatPanel">
-      <input type="text" id="chatInput" class="chat-input" placeholder="Send a message to the agent — add a section, revise content, ask questions..." autocomplete="off" />
+      <input type="text" id="chatInput" class="chat-input" placeholder="Send a message to the agent - add a section, revise content, ask questions..." autocomplete="off" />
       <button class="chat-send" id="chatSendBtn" type="button" disabled>Send</button>
     </div>
 
@@ -27090,7 +28214,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
       // simpleMarkdown: safe because escaping happens BEFORE markdown
       // processing. Adding raw HTML output from user content would break
-      // this safety — always use textContent for user data.
+      // this safety - always use textContent for user data.
       function simpleMarkdown(text) {
         if (!text) return '';
         const escaped = text
@@ -27236,7 +28360,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
             aBadge.textContent = 'A';
             const aText = document.createElement('span');
             aText.className = 'qa-text qa-text-a';
-            aText.textContent = pair.a || '—';
+            aText.textContent = pair.a || '-';
             aRow.appendChild(aBadge);
             aRow.appendChild(aText);
             card.appendChild(aRow);
@@ -27304,7 +28428,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
         if (busy) {
           input.placeholder = 'Agent is processing...';
         } else {
-          input.placeholder = 'Send a message to the agent — add a section, revise content, ask questions...';
+          input.placeholder = 'Send a message to the agent - add a section, revise content, ask questions...';
         }
       }
 
@@ -27462,7 +28586,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
         statusEl.textContent = data.mode.toUpperCase();
         statusEl.className = isDone ? 'status-completed' : '';
         
-        // Render Markdown Path — always visible in completed mode
+        // Render Markdown Path - always visible in completed mode
         const pathContainer = document.getElementById('filePathContainer');
         const pathElement = document.getElementById('markdownPath');
         const mdPath = data.markdownPath || (data.interview && data.interview.markdownPath);
@@ -27480,7 +28604,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
           pathContainer.style.display = 'none';
         }
 
-        // Resume command — only in session-disconnected mode
+        // Resume command - only in session-disconnected mode
         var resumeRow = document.getElementById('resumeRow');
         if (resumeRow) {
           var showResume = data.mode === 'session-disconnected';
@@ -27490,7 +28614,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
           }
         }
 
-        // Nudge actions — only for completed (live session)
+        // Nudge actions - only for completed (live session)
         // session-disconnected can't nudge (no session to receive it)
         const nudgeActions = document.getElementById('nudgeActions');
         const moreBtn = document.getElementById('moreQuestionsBtn');
@@ -27613,7 +28737,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
             if (confirmBtn) confirmBtn.disabled = false;
           } else {
             try { await refresh(); } catch (_) {}
-            schedulePoll(); // Restart polling — nudge may reactivate interview
+            schedulePoll(); // Restart polling - nudge may reactivate interview
           }
         } catch (_err) {
           document.getElementById('submitStatus').textContent = 'Network error.';
@@ -27691,7 +28815,7 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
 // src/interview/dashboard.ts
 function getAuthFilePath(port) {
-  const dataHome = process.env.XDG_DATA_HOME || path14.join(os4.homedir(), ".local", "share");
+  const dataHome = process.env.XDG_DATA_HOME || path14.join(os5.homedir(), ".local", "share");
   return path14.join(dataHome, "opencode", `.dashboard-${port}.json`);
 }
 function writeAuthFile(port, token) {
@@ -27747,7 +28871,7 @@ function hasLiveForSlug(slug, cache) {
 }
 var DEFAULT_DASHBOARD_PORT = 43211;
 function createDashboardServer(config) {
-  const authToken = crypto.randomBytes(32).toString("hex");
+  const authToken = crypto2.randomBytes(32).toString("hex");
   let activeServer = null;
   let baseUrl = null;
   const sessions = new Map;
@@ -27804,15 +28928,19 @@ data: ${JSON.stringify(formatSseState(entry))}
   ]);
   const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
-  const cleanupTimer = setInterval(() => {
-    const cutoff = Date.now() - CACHE_TTL_MS;
-    for (const [id, entry] of stateCache) {
-      if (TERMINAL_MODES.has(entry.mode) && entry.lastUpdatedAt < cutoff) {
-        stateCache.delete(id);
+  function createCleanupTimer() {
+    const timer = setInterval(() => {
+      const cutoff = Date.now() - CACHE_TTL_MS;
+      for (const [id, entry] of stateCache) {
+        if (TERMINAL_MODES.has(entry.mode) && entry.lastUpdatedAt < cutoff) {
+          stateCache.delete(id);
+        }
       }
-    }
-  }, CLEANUP_INTERVAL_MS);
-  cleanupTimer.unref();
+    }, CLEANUP_INTERVAL_MS);
+    timer.unref();
+    return timer;
+  }
+  let cleanupTimer = null;
   let fileCache = null;
   const FILE_CACHE_TTL = 1e4;
   function isAuthenticated(request) {
@@ -27838,7 +28966,7 @@ data: ${JSON.stringify(formatSseState(entry))}
   let scanDays = 30;
   function getKnownDirectories() {
     const dirs = new Set;
-    dirs.add(os4.homedir());
+    dirs.add(os5.homedir());
     for (const session2 of sessions.values()) {
       if (session2.directory)
         dirs.add(session2.directory);
@@ -28555,7 +29683,10 @@ data: ${JSON.stringify(formatSseState(entry))}
   function start() {
     if (baseUrl)
       return Promise.resolve(baseUrl);
-    return new Promise((resolve2, reject) => {
+    if (!cleanupTimer) {
+      cleanupTimer = createCleanupTimer();
+    }
+    return new Promise((resolve3, reject) => {
       const server = createServer((request, response) => {
         handleRequest(request, response).catch((error) => {
           sendJson(response, 500, {
@@ -28582,13 +29713,31 @@ data: ${JSON.stringify(formatSseState(entry))}
         activeServer = server;
         baseUrl = `http://127.0.0.1:${address.port}`;
         writeAuthFile(config.port, authToken);
-        resolve2(baseUrl);
+        resolve3(baseUrl);
       });
     });
   }
   function close() {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+    }
+    for (const clients of sseClients.values()) {
+      for (const response of clients) {
+        try {
+          if (!response.writableEnded && !response.destroyed) {
+            response.end();
+          }
+        } catch {
+          try {
+            response.destroy();
+          } catch {}
+        }
+      }
+    }
+    sseClients.clear();
+    removeAuthFile(config.port);
     if (activeServer) {
-      removeAuthFile(config.port);
       activeServer.closeAllConnections();
       activeServer.close();
       activeServer = null;
@@ -28730,7 +29879,7 @@ async function tryBecomeDashboard(config, maxAttempts = 3) {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("already in use")) {
         if (attempt < maxAttempts - 1) {
-          await new Promise((resolve2) => setTimeout(resolve2, jitterMs()));
+          await new Promise((resolve3) => setTimeout(resolve3, jitterMs()));
           continue;
         }
         return null;
@@ -28741,6 +29890,9 @@ async function tryBecomeDashboard(config, maxAttempts = 3) {
   return null;
 }
 
+// src/interview/dashboard-manager.ts
+import path16 from "node:path";
+
 // src/interview/server.ts
 import {
   createServer as createServer2
@@ -28938,7 +30090,7 @@ function createInterviewServer(deps) {
     if (startPromise) {
       return startPromise;
     }
-    startPromise = new Promise((resolve2, reject) => {
+    startPromise = new Promise((resolve3, reject) => {
       const server = createServer2((request, response) => {
         handle(request, response).catch((error) => {
           sendJson(response, 500, {
@@ -28967,7 +30119,7 @@ function createInterviewServer(deps) {
           return;
         }
         baseUrl = `http://127.0.0.1:${address.port}`;
-        resolve2(baseUrl);
+        resolve3(baseUrl);
       });
     });
     return startPromise;
@@ -29252,8 +30404,9 @@ function buildAnswerPrompt(answers, questions, maxQuestions) {
 }
 
 // src/interview/service.ts
-var COMMAND_NAME3 = "interview";
+var COMMAND_NAME4 = "interview";
 var DEFAULT_MAX_QUESTIONS = 2;
+var MAX_RETAINED_ABANDONED = 50;
 function isTruthyEnvFlag(value) {
   if (!value) {
     return false;
@@ -29312,6 +30465,7 @@ function createInterviewService(ctx, config, deps) {
   let onStateChange = null;
   let onInterviewCreated = null;
   let idCounter = 0;
+  let abandonedOrderCounter = 0;
   function setBaseUrlResolver(resolver) {
     resolveBaseUrl = resolver;
   }
@@ -29386,7 +30540,7 @@ function createInterviewService(ctx, config, deps) {
           return messages;
         }
       }
-      await new Promise((resolve3) => setTimeout(resolve3, 250));
+      await new Promise((resolve4) => setTimeout(resolve4, 250));
     }
     return loadMessages(sessionID);
   }
@@ -29396,6 +30550,29 @@ function createInterviewService(ctx, config, deps) {
   function getInterviewById(interviewId) {
     return interviewsById.get(interviewId) ?? null;
   }
+  function abandonInterview(interview) {
+    if (interview.status !== "abandoned") {
+      interview.abandonedAt = nowIso();
+      interview.abandonedOrder = ++abandonedOrderCounter;
+    }
+    interview.status = "abandoned";
+    pruneAbandonedInterviews();
+  }
+  function pruneAbandonedInterviews() {
+    const abandoned = [...interviewsById.values()].filter((record) => record.status === "abandoned");
+    const overflow = abandoned.length - MAX_RETAINED_ABANDONED;
+    if (overflow <= 0)
+      return;
+    abandoned.sort((a, b) => {
+      const timeDelta = new Date(a.abandonedAt ?? a.createdAt).getTime() - new Date(b.abandonedAt ?? b.createdAt).getTime();
+      if (timeDelta !== 0)
+        return timeDelta;
+      return (a.abandonedOrder ?? 0) - (b.abandonedOrder ?? 0);
+    }).slice(0, overflow).forEach((record) => {
+      interviewsById.delete(record.id);
+      browserOpened.delete(record.id);
+    });
+  }
   async function createInterview(sessionID, idea) {
     const normalizedIdea = idea.trim();
     const activeId = activeInterviewIds.get(sessionID);
@@ -29405,7 +30582,7 @@ function createInterviewService(ctx, config, deps) {
         if (active.idea === normalizedIdea) {
           return active;
         }
-        active.status = "abandoned";
+        abandonInterview(active);
       }
     }
     const messages = await loadMessages(sessionID);
@@ -29435,7 +30612,7 @@ function createInterviewService(ctx, config, deps) {
         if (active.markdownPath === markdownPath) {
           return active;
         }
-        active.status = "abandoned";
+        abandonInterview(active);
       }
     }
     const document = await fs8.readFile(markdownPath, "utf8");
@@ -29531,11 +30708,11 @@ function createInterviewService(ctx, config, deps) {
   }
   function registerCommand(opencodeConfig) {
     const configCommand = opencodeConfig.command;
-    if (!configCommand?.[COMMAND_NAME3]) {
+    if (!configCommand?.[COMMAND_NAME4]) {
       if (!opencodeConfig.command) {
         opencodeConfig.command = {};
       }
-      opencodeConfig.command[COMMAND_NAME3] = {
+      opencodeConfig.command[COMMAND_NAME4] = {
         template: "Start an interview and write a live markdown spec",
         description: "Open a localhost interview UI linked to the current OpenCode session"
       };
@@ -29609,7 +30786,7 @@ function createInterviewService(ctx, config, deps) {
     }
   }
   async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME3) {
+    if (input.command !== COMMAND_NAME4) {
       return;
     }
     const idea = input.arguments.trim();
@@ -29673,7 +30850,7 @@ function createInterviewService(ctx, config, deps) {
       if (!interview) {
         return;
       }
-      interview.status = "abandoned";
+      abandonInterview(interview);
       fileCache = null;
       activeInterviewIds.delete(deletedSessionId);
       log("[interview] session deleted, interview marked abandoned", {
@@ -29802,7 +30979,7 @@ function createInterviewService(ctx, config, deps) {
         `The user sent a freeform message via the dashboard chat panel:`,
         `${message}`,
         ``,
-        `Process this request — it may be a request to add a new section, revise existing content, ask clarifying questions, or make structural changes.`,
+        `Process this request - it may be a request to add a new section, revise existing content, ask clarifying questions, or make structural changes.`,
         `Update the specification document accordingly and include the updated 11-section specification.`,
         `Ask up to ${maxQuestions} clarifying questions if needed using the same <interview_state> JSON block format as before.`
       ].join(`
@@ -29864,7 +31041,7 @@ function createInterviewService(ctx, config, deps) {
           `The user confirmed the interview spec is complete.`,
           ``,
           `Produce a final, polished version of the full spec document.`,
-          `Do NOT include any <interview_state> block — just output the final spec as clean markdown.`,
+          `Do NOT include any <interview_state> block - just output the final spec as clean markdown.`,
           `The spec should be comprehensive, well-structured, and ready for implementation.`
         ].join(`
 `);
@@ -29902,34 +31079,9 @@ function createInterviewService(ctx, config, deps) {
   };
 }
 
-// src/interview/manager.ts
-function createInterviewManager(ctx, config) {
+// src/interview/dashboard-manager.ts
+function createDashboardManager(ctx, config, dashboardPort, outputFolder) {
   const interviewConfig = config.interview;
-  const effectivePort = interviewConfig?.port ?? 0;
-  const dashboardEnabled = interviewConfig?.dashboard === true || effectivePort > 0;
-  const outputFolder = interviewConfig?.outputFolder ?? "interview";
-  if (!dashboardEnabled) {
-    const service2 = createInterviewService(ctx, interviewConfig);
-    const resolvedOutputPath = path16.join(ctx.directory, outputFolder);
-    const server = createInterviewServer({
-      getState: async (interviewId) => service2.getInterviewState(interviewId),
-      listInterviewFiles: async () => service2.listInterviewFiles(),
-      listInterviews: () => service2.listInterviews(),
-      submitAnswers: async (interviewId, answers) => service2.submitAnswers(interviewId, answers),
-      submitBlockComment: async (interviewId, section, comment) => service2.submitBlockComment(interviewId, section, comment),
-      submitChat: async (interviewId, message) => service2.submitChat(interviewId, message),
-      handleNudgeAction: async (interviewId, action) => service2.handleNudgeAction(interviewId, action),
-      outputFolder: resolvedOutputPath,
-      port: 0
-    });
-    service2.setBaseUrlResolver(() => server.ensureStarted());
-    return {
-      registerCommand: (c) => service2.registerCommand(c),
-      handleCommandExecuteBefore: async (input, output) => service2.handleCommandExecuteBefore(input, output),
-      handleEvent: async (input) => service2.handleEvent(input)
-    };
-  }
-  const dashboardPort = effectivePort > 0 ? effectivePort : DEFAULT_DASHBOARD_PORT;
   const service = createInterviewService(ctx, interviewConfig);
   let initDone = false;
   let isDashboard = false;
@@ -29939,6 +31091,12 @@ function createInterviewManager(ctx, config) {
   const registeredSessions = new Set;
   const FALLBACK_POLL_INTERVAL = 1e4;
   let fallbackTimer = null;
+  const stopFallbackTimer = () => {
+    if (!fallbackTimer)
+      return;
+    clearInterval(fallbackTimer);
+    fallbackTimer = null;
+  };
   const startFallbackTimer = () => {
     if (fallbackTimer)
       return;
@@ -30049,7 +31207,7 @@ function createInterviewManager(ctx, config) {
       log("[interview] dashboard election failed or unreachable. Falling back to per-session server.", { error: err instanceof Error ? err.message : String(err) });
       isDashboard = false;
       const resolvedOutputPath = path16.join(ctx.directory, outputFolder);
-      const server = createInterviewServer({
+      const fallbackServer = createInterviewServer({
         getState: async (interviewId) => service.getInterviewState(interviewId),
         listInterviewFiles: async () => service.listInterviewFiles(),
         listInterviews: () => service.listInterviews(),
@@ -30060,7 +31218,7 @@ function createInterviewManager(ctx, config) {
         outputFolder: resolvedOutputPath,
         port: 0
       });
-      service.setBaseUrlResolver(() => server.ensureStarted());
+      service.setBaseUrlResolver(() => fallbackServer.ensureStarted());
       service.setStatePushCallback(() => {});
     } finally {
       initDone = true;
@@ -30076,7 +31234,10 @@ function createInterviewManager(ctx, config) {
     if (!interviewId)
       return;
     try {
-      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/pending?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/pending`, {
+        headers: authHeaders(authToken),
+        signal: AbortSignal.timeout(3000)
+      });
       const body = await res.json();
       if (res.ok && body.answers && body.answers.length > 0) {
         log("[interview] delivering pending answers (HTTP poll)", {
@@ -30096,7 +31257,10 @@ function createInterviewManager(ctx, config) {
     if (!interviewId)
       return;
     try {
-      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/nudge?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/nudge`, {
+        headers: authHeaders(authToken),
+        signal: AbortSignal.timeout(3000)
+      });
       const body = await res.json();
       if (res.ok && body.action) {
         log("[interview] delivering nudge action (HTTP poll)", {
@@ -30116,7 +31280,10 @@ function createInterviewManager(ctx, config) {
     if (!interviewId)
       return;
     try {
-      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/block-comment?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/block-comment`, {
+        headers: authHeaders(authToken),
+        signal: AbortSignal.timeout(3000)
+      });
       const body = await res.json();
       if (res.ok && body.section && body.comment) {
         log("[interview] delivering block comment (HTTP poll)", {
@@ -30136,7 +31303,10 @@ function createInterviewManager(ctx, config) {
     if (!interviewId)
       return;
     try {
-      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/chat?token=${authToken}`, { signal: AbortSignal.timeout(3000) });
+      const res = await fetch(`${dashboardBaseUrl}/api/interviews/${interviewId}/chat`, {
+        headers: authHeaders(authToken),
+        signal: AbortSignal.timeout(3000)
+      });
       const body = await res.json();
       if (res.ok && body.message) {
         log("[interview] delivering chat message (HTTP poll)", {
@@ -30157,9 +31327,12 @@ function createInterviewManager(ctx, config) {
       const sessionID = input.sessionID;
       registeredSessions.add(sessionID);
       if (!isDashboard && dashboardBaseUrl) {
-        fetch(`${dashboardBaseUrl}/api/sessions?token=${authToken}`, {
+        fetch(`${dashboardBaseUrl}/api/sessions`, {
           method: "POST",
-          headers: { "content-type": "application/json" },
+          headers: {
+            ...authHeaders(authToken),
+            "content-type": "application/json"
+          },
           body: JSON.stringify({
             sessionID,
             directory: ctx.directory,
@@ -30177,9 +31350,10 @@ function createInterviewManager(ctx, config) {
       const properties = event.properties ?? {};
       const sessionID = properties.sessionID ?? null;
       await service.handleEvent(input);
-      if (event.type === "session.status") {
+      if (event.type === "session.status" || event.type === "session.idle") {
         const status = properties.status;
-        if (sessionID && status?.type === "idle") {
+        const isIdleEvent = event.type === "session.idle" || status?.type === "idle";
+        if (sessionID && isIdleEvent) {
           const interviewId = service.getActiveInterviewId(sessionID);
           if (!isDashboard && dashboardBaseUrl) {
             await pollPendingAnswers(sessionID);
@@ -30230,11 +31404,17 @@ function createInterviewManager(ctx, config) {
       }
       if (event.type === "session.deleted" && sessionID) {
         registeredSessions.delete(sessionID);
+        if (!isDashboard && registeredSessions.size === 0) {
+          stopFallbackTimer();
+        }
         dashboard?.removeSession(sessionID);
       }
     }
   };
 }
+function authHeaders(token) {
+  return { authorization: `Bearer ${token}` };
+}
 function stateToEntry(interviewId, state) {
   return {
     interviewId,
@@ -30261,17 +31441,23 @@ function stateToEntry(interviewId, state) {
 }
 async function pushStateViaHttp(dashboardUrl, token, interviewId, state) {
   const entry = stateToEntry(interviewId, state);
-  await fetch(`${dashboardUrl}/api/interviews/${interviewId}/state?token=${token}`, {
+  await fetch(`${dashboardUrl}/api/interviews/${interviewId}/state`, {
     method: "POST",
-    headers: { "content-type": "application/json" },
+    headers: {
+      ...authHeaders(token),
+      "content-type": "application/json"
+    },
     body: JSON.stringify(entry),
     signal: AbortSignal.timeout(5000)
   });
 }
 async function registerInterviewViaHttp(dashboardUrl, token, interview) {
-  await fetch(`${dashboardUrl}/api/interviews?token=${token}`, {
+  await fetch(`${dashboardUrl}/api/interviews`, {
     method: "POST",
-    headers: { "content-type": "application/json" },
+    headers: {
+      ...authHeaders(token),
+      "content-type": "application/json"
+    },
     body: JSON.stringify({
       interviewId: interview.id,
       sessionID: interview.sessionID,
@@ -30294,6 +31480,43 @@ async function registerInterviewViaHttp(dashboardUrl, token, interview) {
     });
   });
 }
+
+// src/interview/session-server.ts
+import path17 from "node:path";
+function createPerSessionInterviewServer(ctx, interviewConfig, outputFolder) {
+  const service = createInterviewService(ctx, interviewConfig);
+  const resolvedOutputPath = path17.join(ctx.directory, outputFolder);
+  const server = createInterviewServer({
+    getState: async (interviewId) => service.getInterviewState(interviewId),
+    listInterviewFiles: async () => service.listInterviewFiles(),
+    listInterviews: () => service.listInterviews(),
+    submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
+    submitBlockComment: async (interviewId, section, comment) => service.submitBlockComment(interviewId, section, comment),
+    submitChat: async (interviewId, message) => service.submitChat(interviewId, message),
+    handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
+    outputFolder: resolvedOutputPath,
+    port: 0
+  });
+  service.setBaseUrlResolver(() => server.ensureStarted());
+  return {
+    registerCommand: (c) => service.registerCommand(c),
+    handleCommandExecuteBefore: async (input, output) => service.handleCommandExecuteBefore(input, output),
+    handleEvent: async (input) => service.handleEvent(input)
+  };
+}
+
+// src/interview/manager.ts
+function createInterviewManager(ctx, config) {
+  const interviewConfig = config.interview;
+  const effectivePort = interviewConfig?.port ?? 0;
+  const dashboardEnabled = interviewConfig?.dashboard === true || effectivePort > 0;
+  const outputFolder = interviewConfig?.outputFolder ?? "interview";
+  if (!dashboardEnabled) {
+    return createPerSessionInterviewServer(ctx, interviewConfig, outputFolder);
+  }
+  const dashboardPort = effectivePort > 0 ? effectivePort : DEFAULT_DASHBOARD_PORT;
+  return createDashboardManager(ctx, config, dashboardPort, outputFolder);
+}
 // src/mcp/context7.ts
 var context7 = {
   type: "remote",
@@ -30350,6 +31573,209 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
   return mcps;
 }
 
+// src/multiplexer/herdr/index.ts
+init_compat();
+class HerdrMultiplexer {
+  type = "herdr";
+  binaryPath = null;
+  hasChecked = false;
+  parentPaneId = process.env.HERDR_PANE_ID;
+  paneDirection;
+  constructor(layout = "main-vertical", mainPaneSize = 60) {
+    this.paneDirection = getPaneDirection(layout);
+  }
+  async isAvailable() {
+    if (this.hasChecked) {
+      return this.binaryPath !== null;
+    }
+    this.binaryPath = await this.findBinary();
+    this.hasChecked = true;
+    return this.binaryPath !== null;
+  }
+  isInsideSession() {
+    return !!(process.env.HERDR_ENV || process.env.HERDR_PANE_ID);
+  }
+  async spawnPane(sessionId, description, serverUrl, directory) {
+    const herdr = await this.getBinary();
+    if (!herdr) {
+      log("[herdr] spawnPane: herdr binary not found");
+      return { success: false };
+    }
+    try {
+      const splitArgs = [
+        herdr,
+        "pane",
+        "split",
+        ...this.targetPaneArg(),
+        "--direction",
+        this.paneDirection,
+        "--cwd",
+        directory,
+        "--no-focus"
+      ];
+      log("[herdr] spawnPane: splitting pane", { args: splitArgs });
+      const splitProc = crossSpawn(splitArgs, {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const splitExitCode = await splitProc.exited;
+      const splitStdout = await splitProc.stdout();
+      const splitStderr = await splitProc.stderr();
+      if (splitExitCode !== 0) {
+        log("[herdr] spawnPane: split failed", {
+          exitCode: splitExitCode,
+          stderr: splitStderr.trim()
+        });
+        return { success: false };
+      }
+      const paneId = parsePaneId(splitStdout);
+      if (!paneId) {
+        log("[herdr] spawnPane: could not parse pane_id from output", {
+          stdout: splitStdout.trim()
+        });
+        return { success: false };
+      }
+      await crossSpawn([herdr, "pane", "rename", paneId, description.slice(0, 30)], { stdout: "ignore", stderr: "ignore" }).exited;
+      const opencodeCmd = buildOpencodeAttachCommand(sessionId, serverUrl, directory);
+      log("[herdr] spawnPane: running attach command", {
+        paneId,
+        command: opencodeCmd
+      });
+      const runProc = crossSpawn([herdr, "pane", "run", paneId, opencodeCmd], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const runExitCode = await runProc.exited;
+      if (runExitCode !== 0) {
+        const runStderr = await runProc.stderr();
+        log("[herdr] spawnPane: run failed", {
+          exitCode: runExitCode,
+          stderr: runStderr.trim()
+        });
+        return { success: false };
+      }
+      log("[herdr] spawnPane: SUCCESS", { paneId });
+      return { success: true, paneId };
+    } catch (err) {
+      log("[herdr] spawnPane: exception", { error: String(err) });
+      return { success: false };
+    }
+  }
+  async closePane(paneId) {
+    if (!paneId || paneId === "unknown")
+      return true;
+    const herdr = await this.getBinary();
+    if (!herdr) {
+      log("[herdr] closePane: herdr binary not found");
+      return false;
+    }
+    try {
+      log("[herdr] closePane: sending Ctrl+C", { paneId });
+      await crossSpawn([herdr, "pane", "send-keys", paneId, "ctrl+c"], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+      await new Promise((r) => setTimeout(r, 250));
+      log("[herdr] closePane: closing pane", { paneId });
+      const proc = crossSpawn([herdr, "pane", "close", paneId], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      const stderr = await proc.stderr();
+      log("[herdr] closePane: result", { exitCode, stderr: stderr.trim() });
+      if (exitCode === 0 || exitCode === 1) {
+        return true;
+      }
+      log("[herdr] closePane: failed (pane may already be closed)", {
+        paneId
+      });
+      return false;
+    } catch (err) {
+      log("[herdr] closePane: exception", { error: String(err) });
+      return false;
+    }
+  }
+  async applyLayout(_layout, _mainPaneSize) {}
+  targetPaneArg() {
+    return this.parentPaneId ? [this.parentPaneId] : ["--current"];
+  }
+  async getBinary() {
+    await this.isAvailable();
+    return this.binaryPath;
+  }
+  async findBinary() {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    try {
+      const proc = crossSpawn([cmd, "herdr"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        log("[herdr] findBinary: 'which herdr' failed", { exitCode });
+        return null;
+      }
+      const stdout = await proc.stdout();
+      const path18 = stdout.trim().split(`
+`)[0];
+      if (!path18) {
+        log("[herdr] findBinary: no path in output");
+        return null;
+      }
+      log("[herdr] findBinary: found", { path: path18 });
+      return path18;
+    } catch (err) {
+      log("[herdr] findBinary: exception", { error: String(err) });
+      return null;
+    }
+  }
+}
+function parsePaneId(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed)
+    return null;
+  for (const line of trimmed.split(`
+`)) {
+    const candidate = line.trim();
+    if (!candidate)
+      continue;
+    try {
+      const response = JSON.parse(candidate);
+      const paneId = response.result?.pane?.pane_id;
+      if (paneId)
+        return paneId;
+    } catch {}
+  }
+  log("[herdr] parsePaneId: no pane_id found in output", { stdout: trimmed });
+  return null;
+}
+function getPaneDirection(layout) {
+  switch (layout) {
+    case "main-horizontal":
+    case "even-vertical":
+      return "down";
+    case "main-vertical":
+    case "even-horizontal":
+    case "tiled":
+      return "right";
+  }
+}
+function buildOpencodeAttachCommand(sessionId, serverUrl, directory) {
+  return [
+    "opencode",
+    "attach",
+    quoteShellArg(serverUrl),
+    "--session",
+    quoteShellArg(sessionId),
+    "--dir",
+    quoteShellArg(directory)
+  ].join(" ");
+}
+function quoteShellArg(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 // src/multiplexer/tmux/index.ts
 init_compat();
 var TMUX_LAYOUT_DEBOUNCE_MS = 150;
@@ -30385,9 +31811,9 @@ class TmuxMultiplexer {
       return { success: false };
     }
     try {
-      const quotedDirectory = quoteShellArg(directory);
-      const quotedUrl = quoteShellArg(serverUrl);
-      const quotedSessionId = quoteShellArg(sessionId);
+      const quotedDirectory = quoteShellArg2(directory);
+      const quotedUrl = quoteShellArg2(serverUrl);
+      const quotedSessionId = quoteShellArg2(sessionId);
       const opencodeCmd = [
         "opencode",
         "attach",
@@ -30569,30 +31995,30 @@ class TmuxMultiplexer {
         return null;
       }
       const stdout = await proc.stdout();
-      const path17 = stdout.trim().split(`
+      const path18 = stdout.trim().split(`
 `)[0];
-      if (!path17) {
+      if (!path18) {
         log("[tmux] findBinary: no path in output");
         return null;
       }
-      const verifyProc = crossSpawn([path17, "-V"], {
+      const verifyProc = crossSpawn([path18, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
       const verifyExit = await verifyProc.exited;
       if (verifyExit !== 0) {
-        log("[tmux] findBinary: tmux -V failed", { path: path17, verifyExit });
+        log("[tmux] findBinary: tmux -V failed", { path: path18, verifyExit });
         return null;
       }
-      log("[tmux] findBinary: found", { path: path17 });
-      return path17;
+      log("[tmux] findBinary: found", { path: path18 });
+      return path18;
     } catch (err) {
       log("[tmux] findBinary: exception", { error: String(err) });
       return null;
     }
   }
 }
-function quoteShellArg(value) {
+function quoteShellArg2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
@@ -30612,7 +32038,7 @@ class ZellijMultiplexer {
   paneDirection;
   constructor(layout = "main-vertical", mainPaneSize = 60, paneMode = "agent-tab") {
     this.paneMode = paneMode;
-    this.paneDirection = getPaneDirection(layout);
+    this.paneDirection = getPaneDirection2(layout);
   }
   async isAvailable() {
     if (this.hasChecked) {
@@ -30653,7 +32079,7 @@ class ZellijMultiplexer {
     }
   }
   async createPaneInCurrentTab(zellij, sessionId, serverUrl, directory, description) {
-    const opencodeCmd = buildOpencodeAttachCommand(sessionId, serverUrl, directory);
+    const opencodeCmd = buildOpencodeAttachCommand2(sessionId, serverUrl, directory);
     const paneName = description.slice(0, 30).replace(/"/g, "\\\"");
     const targetTabId = await this.getParentTabId(zellij);
     const args = [
@@ -30682,7 +32108,7 @@ class ZellijMultiplexer {
     return { success: false };
   }
   async createPaneInAgentTab(zellij, sessionId, serverUrl, directory, description) {
-    const opencodeCmd = buildOpencodeAttachCommand(sessionId, serverUrl, directory);
+    const opencodeCmd = buildOpencodeAttachCommand2(sessionId, serverUrl, directory);
     const paneName = description.slice(0, 30).replace(/"/g, "\\\"");
     const currentTabId = await this.getCurrentTabId(zellij);
     const inAgentTab = currentTabId === this.agentTabId;
@@ -30751,7 +32177,7 @@ class ZellijMultiplexer {
   }
   async runInPane(zellij, paneId, sessionId, serverUrl, directory, description) {
     try {
-      const opencodeCmd = buildOpencodeAttachCommand(sessionId, serverUrl, directory);
+      const opencodeCmd = buildOpencodeAttachCommand2(sessionId, serverUrl, directory);
       await crossSpawn([zellij, "action", "focus-pane", "--pane-id", paneId], {
         stdout: "ignore",
         stderr: "ignore"
@@ -30975,7 +32401,7 @@ class ZellijMultiplexer {
 function normalizePaneId(paneId) {
   return paneId.replace(/^terminal_/, "");
 }
-function getPaneDirection(layout) {
+function getPaneDirection2(layout) {
   switch (layout) {
     case "main-vertical":
       return "right";
@@ -30987,21 +32413,21 @@ function getPaneDirection(layout) {
       return null;
   }
 }
-function buildOpencodeAttachCommand(sessionId, serverUrl, directory) {
+function buildOpencodeAttachCommand2(sessionId, serverUrl, directory) {
   return [
     "opencode",
     "attach",
-    quoteShellArg2(serverUrl),
+    quoteShellArg3(serverUrl),
     "--session",
-    quoteShellArg2(sessionId),
+    quoteShellArg3(sessionId),
     "--dir",
-    quoteShellArg2(directory)
+    quoteShellArg3(directory)
   ].join(" ");
 }
 function buildShellLaunchCommand(command) {
-  return ["sh", "-lc", quoteShellArg2(command)].join(" ");
+  return ["sh", "-lc", quoteShellArg3(command)].join(" ");
 }
-function quoteShellArg2(value) {
+function quoteShellArg3(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
@@ -31022,6 +32448,10 @@ function getMultiplexer(config) {
       multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
       actualType = "zellij";
       break;
+    case "herdr":
+      multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
+      actualType = "herdr";
+      break;
     case "auto": {
       if (process.env.TMUX) {
         multiplexer = new TmuxMultiplexer(config.layout, config.main_pane_size);
@@ -31029,6 +32459,9 @@ function getMultiplexer(config) {
       } else if (process.env.ZELLIJ) {
         multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
         actualType = "zellij";
+      } else if (process.env.HERDR_ENV || process.env.HERDR_PANE_ID) {
+        multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
+        actualType = "herdr";
       } else {
         log("[multiplexer] auto: not inside any session, disabling");
         return null;
@@ -31194,7 +32627,7 @@ class MultiplexerSessionManager {
         tracked: this.sessions.has(sessionId2),
         known: this.knownSessions.has(sessionId2),
         ownerInstanceId: this.sessions.get(sessionId2)?.ownerInstanceId,
-        backgroundJobState: this.backgroundJobBoard?.get(sessionId2)?.state
+        backgroundJobState: this.backgroundJobState(sessionId2)
       });
       await this.closeSession(sessionId2, "idle");
       return;
@@ -31212,22 +32645,23 @@ class MultiplexerSessionManager {
         tracked: this.sessions.has(sessionId),
         known: this.knownSessions.has(sessionId),
         ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
-        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+        backgroundJobState: this.backgroundJobState(sessionId)
       });
       await this.closeSession(sessionId, "idle");
       return;
     }
     if (statusType) {
-      this.deferredIdleCloses.delete(sessionId);
-      if (statusType !== "busy")
+      if (statusType !== "busy") {
+        this.deferredIdleCloses.delete(sessionId);
         return;
+      }
       log("[multiplexer-session-manager] session busy event received", {
         instanceId: this.instanceId,
         sessionId,
         tracked: this.sessions.has(sessionId),
         known: this.knownSessions.has(sessionId),
         ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
-        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+        backgroundJobState: this.backgroundJobState(sessionId)
       });
       await this.respawnIfKnown(sessionId);
     }
@@ -31246,7 +32680,7 @@ class MultiplexerSessionManager {
       tracked: this.sessions.has(sessionId),
       known: this.knownSessions.has(sessionId),
       ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
-      backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+      backgroundJobState: this.backgroundJobState(sessionId)
     });
     this.deferredIdleCloses.delete(sessionId);
     await this.closeSession(sessionId, "deleted");
@@ -31363,7 +32797,7 @@ class MultiplexerSessionManager {
         sessionId,
         paneId: tracked.paneId,
         reason,
-        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+        backgroundJobState: this.backgroundJobState(sessionId)
       });
       return;
     }
@@ -31374,7 +32808,7 @@ class MultiplexerSessionManager {
       sessionId,
       paneId: tracked.paneId,
       reason,
-      backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state,
+      backgroundJobState: this.backgroundJobState(sessionId),
       parentId: tracked.parentId,
       title: tracked.title
     });
@@ -31475,8 +32909,11 @@ class MultiplexerSessionManager {
   getSessionId(event) {
     return event.properties?.info?.id ?? event.properties?.sessionID;
   }
+  backgroundJobState(sessionId) {
+    return this.backgroundJobBoard?.getState(sessionId);
+  }
   isRunningBackgroundJob(sessionId) {
-    return this.backgroundJobBoard?.get(sessionId)?.state === "running";
+    return this.backgroundJobBoard?.isRunning(sessionId) ?? false;
   }
   async retryDeferredIdleClose(sessionId) {
     if (!this.enabled)
@@ -31633,8 +33070,8 @@ class AcpClient {
   request(method, params) {
     const id = this.next++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve3, reject) => {
-      this.pending.set(id, { resolve: resolve3, reject });
+    return new Promise((resolve4, reject) => {
+      this.pending.set(id, { resolve: resolve4, reject });
       this.child.stdin.write(`${JSON.stringify(payload)}
 `, (error) => {
         if (!error)
@@ -31651,7 +33088,7 @@ class AcpClient {
   async drain() {
     this.lastUpdate = Date.now();
     while (this.activeRequests > 0 || Date.now() - this.lastUpdate < 100) {
-      await new Promise((resolve3) => setTimeout(resolve3, 25));
+      await new Promise((resolve4) => setTimeout(resolve4, 25));
     }
   }
   async receive(line) {
@@ -31876,10 +33313,10 @@ import { existsSync as existsSync11 } from "node:fs";
 // src/tools/ast-grep/constants.ts
 import { existsSync as existsSync10, statSync as statSync5 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { dirname as dirname10, join as join15 } from "node:path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir6 } from "node:os";
 import { join as join14 } from "node:path";
@@ -31934,8 +33371,8 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   if (existsSync9(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os5 } = platformInfo;
-  const assetName = `app-${arch}-${os5}.zip`;
+  const { arch, os: os6 } = platformInfo;
+  const assetName = `app-${arch}-${os6}.zip`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
@@ -31951,7 +33388,7 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
     await crossWrite(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
     if (existsSync9(archivePath)) {
-      unlinkSync4(archivePath);
+      unlinkSync5(archivePath);
     }
     if (process.platform !== "win32" && existsSync9(binaryPath)) {
       chmodSync2(binaryPath, 493);
@@ -32034,7 +33471,7 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire3(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname9(cliPkgPath);
+    const cliDir = dirname10(cliPkgPath);
     const sgPath = join15(cliDir, binaryName);
     if (existsSync10(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
@@ -32045,7 +33482,7 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire3(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname9(pkgPath);
+      const pkgDir = dirname10(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join15(pkgDir, astGrepName);
       if (existsSync10(binaryPath) && isValidBinary(binaryPath)) {
@@ -32055,9 +33492,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path17 of homebrewPaths) {
-      if (existsSync10(path17) && isValidBinary(path17)) {
-        return path17;
+    for (const path18 of homebrewPaths) {
+      if (existsSync10(path18) && isValidBinary(path18)) {
+        return path18;
       }
     }
   }
@@ -32074,8 +33511,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path17) {
-  resolvedCliPath = path17;
+function setSgCliPath(path18) {
+  resolvedCliPath = path18;
 }
 var DEFAULT_TIMEOUT_MS = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -32449,9 +33886,9 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
         parentSessionID,
         requested,
         resolvedTaskID: job?.taskID,
-        alias: job?.alias,
-        state: job?.state,
-        terminalState: job?.terminalState,
+        alias: job ? options.backgroundJobBoard.field(job.taskID, "alias") : undefined,
+        state: job ? options.backgroundJobBoard.field(job.taskID, "state") : undefined,
+        terminalState: job ? options.backgroundJobBoard.field(job.taskID, "terminalState") : undefined,
         cancellationRequested: job?.cancellationRequested
       });
       if (!job) {
@@ -32464,11 +33901,12 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
             return unknownTaskOutput(requested, "cannot cancel parent session");
           }
           const knownJob = options.backgroundJobBoard.get(requested);
-          if (knownJob && knownJob.parentSessionID !== parentSessionID) {
+          const ownerParentSessionID = options.backgroundJobBoard.getParentSessionID(requested);
+          if (knownJob && ownerParentSessionID !== parentSessionID) {
             log("[cancel-task] rejected unowned tracked raw session", {
               parentSessionID,
               taskID: requested,
-              ownerParentSessionID: knownJob.parentSessionID
+              ownerParentSessionID
             });
             return unknownTaskOutput(requested, "unknown or unowned background task");
           }
@@ -32493,9 +33931,11 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
         await abortAndVerifySession(options, job.taskID);
       } catch (error) {
         const stillRunning = error instanceof SessionStillRunningError;
+        const boardRunning = options.backgroundJobBoard.isRunning(job.taskID);
         log("[cancel-task] abort failed", {
           taskID: job.taskID,
           stillRunning,
+          boardRunning,
           error: error instanceof Error ? error.message : String(error)
         });
         options.backgroundJobBoard.updateStatus({
@@ -32514,20 +33954,20 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
         ].join(`
 `);
       }
-      const cancelled = options.backgroundJobBoard.markCancelled(job.taskID, args.reason, Date.now(), { force: true });
+      options.backgroundJobBoard.markCancelled(job.taskID, args.reason, Date.now(), { force: true });
+      const state = options.backgroundJobBoard.getState(job.taskID);
       log("[cancel-task] marked job cancelled after verified abort", {
         taskID: job.taskID,
-        alias: job.alias,
-        previousState: job.state,
-        state: cancelled?.state,
-        cancellationRequested: cancelled?.cancellationRequested
+        alias: options.backgroundJobBoard.field(job.taskID, "alias"),
+        state,
+        cancellationRequested: options.backgroundJobBoard.field(job.taskID, "cancellationRequested")
       });
       return [
         `task_id: ${job.taskID}`,
-        `state: ${cancelled?.state ?? "cancelled"}`,
+        `state: ${state ?? "cancelled"}`,
         "",
         "<task_error>",
-        cancelled?.resultSummary ?? "cancelled",
+        options.backgroundJobBoard.getResultSummary(job.taskID) ?? "cancelled",
         "</task_error>"
       ].join(`
 `);
@@ -32609,10 +34049,10 @@ async function abortAndVerifySession(options, taskID) {
       statusKeys: statusSnapshot.keys,
       stableStoppedSince,
       stableStoppedForMs: stableStoppedSince ? Date.now() - stableStoppedSince : 0,
-      boardState: options.backgroundJobBoard.get(taskID)?.state,
-      boardLastLiveBusyAt: options.backgroundJobBoard.get(taskID)?.lastLiveBusyAt
+      boardState: options.backgroundJobBoard.getState(taskID),
+      boardLastLiveBusyAt: options.backgroundJobBoard.getLastLiveBusyAt(taskID)
     });
-    const boardLastLiveBusyAt = options.backgroundJobBoard.get(taskID)?.lastLiveBusyAt;
+    const boardLastLiveBusyAt = options.backgroundJobBoard.getLastLiveBusyAt(taskID);
     if (boardLastLiveBusyAt && boardLastLiveBusyAt >= abortStartedAt) {
       log("[cancel-task] abort verification saw board busy after abort", {
         taskID,
@@ -32769,7 +34209,7 @@ async function getSessionStatus(client, taskID) {
   }
 }
 function delay2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function isSessionID(value) {
   return /^ses_[\w-]+$/.test(value);
@@ -32861,10 +34301,10 @@ Returns the councillor responses with a summary footer.`,
         const trulyIgnored = hasMaster && !legacyMasterModel ? deprecated : deprecated.filter((f) => f !== "master");
         const parts = [];
         if (hasMaster && legacyMasterModel) {
-          parts.push(`\`council.master\` is deprecated and will be removed in a future version. Its \`model\` is currently used as a fallback for the council agent — add a \`council\` entry to your preset to make this explicit.`);
+          parts.push(`\`council.master\` is deprecated and will be removed in a future version. Its \`model\` is currently used as a fallback for the council agent - add a \`council\` entry to your preset to make this explicit.`);
         }
         if (trulyIgnored.length > 0) {
-          parts.push(`${trulyIgnored.map((f) => `\`council.${f}\``).join(", ")} ${trulyIgnored.length === 1 ? "is" : "are"} deprecated and ignored — remove ${trulyIgnored.length === 1 ? "it" : "them"} from your config.`);
+          parts.push(`${trulyIgnored.map((f) => `\`council.${f}\``).join(", ")} ${trulyIgnored.length === 1 ? "is" : "are"} deprecated and ignored - remove ${trulyIgnored.length === 1 ? "it" : "them"} from your config.`);
         }
         output += `
 ⚠ Config warning: ${parts.join(" ")}`;
@@ -32879,15 +34319,15 @@ import * as fs10 from "node:fs";
 
 // src/tui-state.ts
 import * as fs9 from "node:fs";
-import * as os5 from "node:os";
-import * as path17 from "node:path";
+import * as os6 from "node:os";
+import * as path18 from "node:path";
 var STATE_DIR = "oh-my-opencode-slim";
 var STATE_FILE = "tui-state.json";
 function dataDir() {
-  return process.env.XDG_DATA_HOME ?? path17.join(os5.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME ?? path18.join(os6.homedir(), ".local", "share");
 }
 function getTuiStatePath() {
-  return path17.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
+  return path18.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
 }
 function emptySnapshot() {
   return {
@@ -32925,7 +34365,7 @@ async function readTuiSnapshotAsync() {
 function writeTuiSnapshot(snapshot) {
   try {
     const filePath = getTuiStatePath();
-    fs9.mkdirSync(path17.dirname(filePath), { recursive: true });
+    fs9.mkdirSync(path18.dirname(filePath), { recursive: true });
     fs9.writeFileSync(filePath, `${JSON.stringify(snapshot)}
 `);
   } catch {}
@@ -32956,11 +34396,11 @@ function recordTuiAgentModel(input) {
 }
 
 // src/tools/preset-manager.ts
-var COMMAND_NAME4 = "preset";
+var COMMAND_NAME5 = "preset";
 function createPresetManager(ctx, config) {
   let activePreset = getActiveRuntimePreset() ?? config.preset ?? null;
   async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME4) {
+    if (input.command !== COMMAND_NAME5) {
       return;
     }
     output.parts.length = 0;
@@ -32979,11 +34419,11 @@ function createPresetManager(ctx, config) {
   }
   function registerCommand(opencodeConfig) {
     const configCommand = opencodeConfig.command;
-    if (!configCommand?.[COMMAND_NAME4]) {
+    if (!configCommand?.[COMMAND_NAME5]) {
       if (!opencodeConfig.command) {
         opencodeConfig.command = {};
       }
-      opencodeConfig.command[COMMAND_NAME4] = {
+      opencodeConfig.command[COMMAND_NAME5] = {
         template: "List available presets and switch between them",
         description: "Switch agent presets at runtime (e.g., /preset cheap, /preset powerful)"
       };
@@ -33138,15 +34578,15 @@ 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 os6 from "node:os";
-import path21 from "node:path";
+import os7 from "node:os";
+import path22 from "node:path";
 import {
   tool as tool5
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -33167,10 +34607,10 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
 async function saveBinary(binaryDir, data, contentType, filename) {
   await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path18.parse(initialName);
+  const parsed = path19.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path18.join(binaryDir, candidateName);
+    const file = path19.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -33184,21 +34624,21 @@ async function saveBinary(binaryDir, data, contentType, filename) {
   throw new Error("Unable to allocate unique filename for binary content");
 }
 
-// node_modules/.pnpm/lru-cache@11.3.6/node_modules/lru-cache/dist/esm/node/index.min.js
-import { tracingChannel as I, channel as G } from "node:diagnostics_channel";
-var S = G("lru-cache:metrics");
-var W = I("lru-cache");
-var C = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+// node_modules/lru-cache/dist/esm/node/index.min.js
+import { tracingChannel as j, channel as I } from "node:diagnostics_channel";
+var S = I("lru-cache:metrics");
+var W = j("lru-cache");
 var D = () => S.hasSubscribers || W.hasSubscribers;
-var U = new Set;
-var L = typeof process == "object" && process ? process : {};
+var G = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var M = new Set;
+var C = typeof process == "object" && process ? process : {};
 var P = (u, e, t, i) => {
-  typeof L.emitWarning == "function" ? L.emitWarning(u, e, t, i) : console.error(`[${t}] ${e}: ${u}`);
+  typeof C.emitWarning == "function" ? C.emitWarning(u, e, t, i) : console.error(`[${t}] ${e}: ${u}`);
 };
-var H = (u) => !U.has(u);
-var X = Symbol("type");
+var H = (u) => !M.has(u);
+var $ = Symbol("type");
 var F = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u);
-var j = (u) => F(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null;
+var U = (u) => F(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null;
 var O = class extends Array {
   constructor(e) {
     super(e), this.fill(0);
@@ -33209,7 +34649,7 @@ var R = class u {
   length;
   static #o = false;
   static create(e) {
-    let t = j(e);
+    let t = U(e);
     if (!t)
       return [];
     u.#o = true;
@@ -33228,11 +34668,11 @@ var R = class u {
     return this.heap[--this.length];
   }
 };
-var M = class u2 {
+var L = class u2 {
   #o;
   #u;
   #w;
-  #x;
+  #D;
   #S;
   #M;
   #U;
@@ -33303,7 +34743,7 @@ var M = class u2 {
     return this.#w;
   }
   get onInsert() {
-    return this.#x;
+    return this.#D;
   }
   get disposeAfter() {
     return this.#S;
@@ -33312,9 +34752,9 @@ var M = class u2 {
     let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z7, perf: x } = e;
     if (x !== undefined && typeof x?.now != "function")
       throw new TypeError("perf option must have a now() method if specified");
-    if (this.#m = x ?? C, t !== 0 && !F(t))
+    if (this.#m = x ?? G, t !== 0 && !F(t))
       throw new TypeError("max option must be a nonnegative integer");
-    let v = t ? j(t) : Array;
+    let v = t ? U(t) : Array;
     if (!v)
       throw new Error("invalid max value: " + t);
     if (this.#o = t, this.#u = T, this.maxEntrySize = w || this.#u, this.sizeCalculation = y, this.sizeCalculation) {
@@ -33327,7 +34767,7 @@ var M = class u2 {
       throw new TypeError("memoMethod must be a function if defined");
     if (this.#U = m, a !== undefined && typeof a != "function")
       throw new TypeError("fetchMethod must be a function if specified");
-    if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({ length: t }).fill(undefined), this.#t = Array.from({ length: t }).fill(undefined), this.#a = new v(t), this.#c = new v(t), this.#l = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof l == "function" && (this.#w = l), typeof c == "function" && (this.#x = c), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#j = !!this.#x, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z7, this.maxEntrySize !== 0) {
+    if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({ length: t }).fill(undefined), this.#t = Array.from({ length: t }).fill(undefined), this.#a = new v(t), this.#c = new v(t), this.#l = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof l == "function" && (this.#w = l), typeof c == "function" && (this.#D = c), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#j = !!this.#D, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z7, this.maxEntrySize !== 0) {
       if (this.#u !== 0 && !F(this.#u))
         throw new TypeError("maxSize must be a positive integer if specified");
       if (!F(this.maxEntrySize))
@@ -33343,7 +34783,7 @@ var M = class u2 {
       throw new TypeError("At least one of max, maxSize, or ttl is required");
     if (!this.ttlAutopurge && !this.#o && !this.#u) {
       let E = "LRU_CACHE_UNBOUNDED";
-      H(E) && (U.add(E), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, u2));
+      H(E) && (M.add(E), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, u2));
     }
   }
   getRemainingTTL(e) {
@@ -33355,7 +34795,7 @@ var M = class u2 {
     let i = this.ttlAutopurge ? Array.from({ length: this.#o }) : undefined;
     this.#g = i, this.#N = (r, h, l = this.#m.now()) => {
       t[r] = h !== 0 ? l : 0, e[r] = h, s(r, h);
-    }, this.#D = (r) => {
+    }, this.#x = (r) => {
       t[r] = e[r] !== 0 ? this.#m.now() : 0, s(r, e[r]);
     };
     let s = this.ttlAutopurge ? (r, h) => {
@@ -33399,7 +34839,7 @@ var M = class u2 {
       return !!l && !!h && (n || o()) - h > l;
     };
   }
-  #D = () => {};
+  #x = () => {};
   #E = () => {};
   #N = () => {};
   #p = () => false;
@@ -33565,7 +35005,7 @@ var M = class u2 {
       return this.#v(e, "set"), h && (h.set = "miss", h.maxEntrySizeExceeded = true), this;
     let f = this.#n === 0 ? undefined : this.#s.get(e);
     if (f === undefined)
-      f = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[f] = e, this.#t[f] = t, this.#s.set(e, f), this.#a[this.#h] = f, this.#c[f] = this.#h, this.#h = f, this.#n++, this.#I(f, c, h), h && (h.set = "add"), l = false, this.#j && this.#x?.(t, e, "add");
+      f = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[f] = e, this.#t[f] = t, this.#s.set(e, f), this.#a[this.#h] = f, this.#c[f] = this.#h, this.#h = f, this.#n++, this.#I(f, c, h), h && (h.set = "add"), l = false, this.#j && this.#D?.(t, e, "add");
     else {
       this.#L(f);
       let g = this.#t[f];
@@ -33629,7 +35069,7 @@ var M = class u2 {
       if (this.#p(n))
         s && (s.has = "stale", this.#E(s, n));
       else
-        return i && this.#D(n), s && (s.has = "hit", this.#E(s, n)), true;
+        return i && this.#x(n), s && (s.has = "hit", this.#E(s, n)), true;
     } else
       s && (s.has = "miss");
     return false;
@@ -33687,7 +35127,7 @@ var M = class u2 {
     let i = W.hasSubscribers, { status: s = D() ? {} : undefined } = t;
     t.status = s, s && t.context && (s.context = t.context);
     let n = this.#B(e, t);
-    return s && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {})), n;
+    return s && D() && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {})), n;
   }
   async#B(e, t = {}) {
     let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: r = this.noDisposeOnSet, size: h = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: g = this.allowStaleOnFetchRejection, ignoreFetchAbort: p = this.ignoreFetchAbort, allowStaleOnFetchAbort: T = this.allowStaleOnFetchAbort, context: w, forceRefresh: y = false, status: a, signal: m } = t;
@@ -33706,7 +35146,7 @@ var M = class u2 {
       }
       let A = this.#p(b);
       if (!y && !A)
-        return a && (a.fetch = "hit"), this.#L(b), s && this.#D(b), a && this.#E(a, b), d;
+        return a && (a.fetch = "hit"), this.#L(b), s && this.#x(b), a && this.#E(a, b), d;
       let z7 = this.#P(e, b, _, w), v = z7.__staleWhileFetching !== undefined && i;
       return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = true)), v ? z7.__staleWhileFetching : z7.__returned = z7;
     }
@@ -33715,7 +35155,7 @@ var M = class u2 {
     let i = W.hasSubscribers, { status: s = D() ? {} : undefined } = t;
     t.status = s, s && t.context && (s.context = t.context);
     let n = this.#K(e, t);
-    return s && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {})), n;
+    return s && D() && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {})), n;
   }
   async#K(e, t = {}) {
     let i = await this.#B(e, t);
@@ -33754,7 +35194,7 @@ var M = class u2 {
       return;
     }
     let h = this.#t[r], l = this.#e(h);
-    return o && this.#E(o, r), this.#p(r) ? l ? (o && (o.get = "stale-fetching"), i && h.__staleWhileFetching !== undefined ? (o && (o.returnedStale = true), h.__staleWhileFetching) : undefined) : (n || this.#v(e, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = true), h) : undefined) : (o && (o.get = l ? "fetching" : "hit"), this.#L(r), s && this.#D(r), l ? h.__staleWhileFetching : h);
+    return o && this.#E(o, r), this.#p(r) ? l ? (o && (o.get = "stale-fetching"), i && h.__staleWhileFetching !== undefined ? (o && (o.returnedStale = true), h.__staleWhileFetching) : undefined) : (n || this.#v(e, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = true), h) : undefined) : (o && (o.get = l ? "fetching" : "hit"), this.#L(r), s && this.#x(r), l ? h.__staleWhileFetching : h);
   }
   #$(e, t) {
     this.#c[t] = e, this.#a[e] = t;
@@ -33824,7 +35264,7 @@ var M = class u2 {
 };
 
 // src/tools/smartfetch/network.ts
-import path19 from "node:path";
+import path20 from "node:path";
 
 // src/tools/smartfetch/utils.ts
 var import_readability = __toESM(require_readability(), 1);
@@ -34549,7 +35989,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path19.parse(name);
+  const parsed = path20.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -34659,7 +36099,7 @@ async function probeLlmsText(url, timeoutMs, signal, fallbackOrigin) {
 }
 
 // src/tools/smartfetch/cache.ts
-var CACHE = new M({
+var CACHE = new L({
   maxSize: 50 * 1024 * 1024,
   ttl: 15 * 60 * 1000,
   sizeCalculation: (value) => {
@@ -34721,7 +36161,7 @@ function isInvalidLlmsResult(fetchResult) {
 // src/tools/smartfetch/secondary-model.ts
 import { existsSync as existsSync12 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -34747,7 +36187,7 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path20.join(baseDir, file);
+    const fullPath = path21.join(baseDir, file);
     if (existsSync12(fullPath))
       return fullPath;
   }
@@ -34764,7 +36204,7 @@ async function readOpenCodeConfigFile(configPath) {
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path20.join(directory, ".opencode");
+  const projectDir = path21.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -34864,7 +36304,7 @@ async function deleteSessionSafely(client, sessionId, directory) {
         console.warn(`[smartfetch] Failed to clean up secondary session ${sessionId} ` + `after ${SESSION_DELETE_RETRIES} attempts: ` + (error instanceof Error ? error.message : String(error)));
         return;
       }
-      await new Promise((resolve3) => setTimeout(resolve3, _testConfig.deleteRetryDelayMs));
+      await new Promise((resolve4) => setTimeout(resolve4, _testConfig.deleteRetryDelayMs));
     }
   }
 }
@@ -34946,7 +36386,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z7 = tool5.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path21.join(os6.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path22.join(os7.tmpdir(), "opencode-smartfetch");
   return tool5({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -35554,6 +36994,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let foregroundFallback;
   let deepworkCommandHook;
   let reflectCommandHook;
+  let loopCommandHook;
   let taskSessionManagerHook;
   let backgroundJobBoard;
   let interviewManager;
@@ -35578,8 +37019,8 @@ var OhMyOpenCodeLite = async (ctx) => {
     }
     disabledAgents = getDisabledAgents(config);
     rewriteDisplayNameMentions = createDisplayNameMentionRewriter(config);
-    agentDefs = createAgents(config);
-    agents = getAgentConfigs(config);
+    agentDefs = createAgents(config, { projectDirectory: ctx.directory });
+    agents = getAgentConfigs(config, { projectDirectory: ctx.directory });
     modelArrayMap = {};
     runtimeChains = {};
     for (const agentDef of agentDefs) {
@@ -35615,7 +37056,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? 8
     });
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig, backgroundJobBoard);
-    backgroundJobBoard.setTerminalStateListener((taskID) => {
+    backgroundJobBoard.addTerminalStateListener((taskID) => {
       multiplexerSessionManager.retryDeferredIdleClose(taskID);
     });
     autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
@@ -35635,6 +37076,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
     deepworkCommandHook = createDeepworkCommandHook();
     reflectCommandHook = createReflectCommandHook();
+    loopCommandHook = createLoopCommandHook();
     taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
       maxSessionsPerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? 2,
       readContextMinLines: config.backgroundJobs?.readContextMinLines ?? 10,
@@ -35764,9 +37206,11 @@ var OhMyOpenCodeLite = async (ctx) => {
           const chosen = models[0];
           const entry = configAgent[agentName];
           if (entry) {
-            entry.model = chosen.id;
-            if (chosen.variant) {
-              entry.variant = chosen.variant;
+            if (entry.model === undefined) {
+              entry.model = chosen.id;
+              if (chosen.variant) {
+                entry.variant = chosen.variant;
+              }
             }
           } else {
             configAgent[agentName] = {
@@ -35906,6 +37350,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       interviewManager.registerCommand(opencodeConfig);
       deepworkCommandHook.registerCommand(opencodeConfig);
       reflectCommandHook.registerCommand(opencodeConfig);
+      loopCommandHook.registerCommand(opencodeConfig);
       presetManager.registerCommand(opencodeConfig);
     },
     event: async (input) => {
@@ -35979,6 +37424,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       await presetManager.handleCommandExecuteBefore(input, output);
       await deepworkCommandHook.handleCommandExecuteBefore(input, output);
       await reflectCommandHook.handleCommandExecuteBefore(input, output);
+      await loopCommandHook.handleCommandExecuteBefore(input, output);
     },
     "chat.headers": chatHeadersHook["chat.headers"],
     "chat.message": async (input, output) => {