oh-my-opencode-lite 0.1.1 → 0.1.3

package/dist/index.js

@@ -17211,19 +17211,6 @@ var DelegationConfigSchema = exports_external.object({
   storage_dir: exports_external.string().optional(),
   timeout: exports_external.number().optional().default(DEFAULT_DELEGATION_TIMEOUT)
 });
-var ClarificationGateModeSchema = exports_external.enum([
-  "off",
-  "explicit-only",
-  "auto",
-  "auto-for-planning"
-]);
-var ClarificationGateConfigSchema = exports_external.object({
-  mode: ClarificationGateModeSchema.default("auto"),
-  min_scope_signals: exports_external.number().min(0).default(2),
-  hard_complex_signal_threshold: exports_external.number().min(0).default(3),
-  explicit_keywords: exports_external.array(exports_external.string()).optional(),
-  planning_keywords: exports_external.array(exports_external.string()).optional()
-});
 var ArtifactStoreModeSchema = exports_external.enum([
   "thoth-mem",
   "openspec",
@@ -17256,7 +17243,6 @@ var PluginConfigSchema = exports_external.object({
   fallback: FailoverConfigSchema.optional(),
   thoth: ThothConfigSchema.optional(),
   delegation: DelegationConfigSchema.optional(),
-  clarificationGate: ClarificationGateConfigSchema.optional(),
   artifactStore: ArtifactStoreConfigSchema.optional()
 });
 
@@ -17325,7 +17311,6 @@ function loadPluginConfig(directory) {
       fallback: deepMerge(config2.fallback, projectConfig.fallback),
       thoth: deepMerge(config2.thoth, projectConfig.thoth),
       delegation: deepMerge(config2.delegation, projectConfig.delegation),
-      clarificationGate: deepMerge(config2.clarificationGate, projectConfig.clarificationGate),
       artifactStore: deepMerge(config2.artifactStore, projectConfig.artifactStore)
     };
   }
@@ -17374,6 +17359,17 @@ function getAgentOverride(config2, name) {
   return overrides[name] ?? overrides[Object.keys(AGENT_ALIASES).find((k) => AGENT_ALIASES[k] === name) ?? ""];
 }
 // src/agents/prompt-utils.ts
+var QUESTION_PROTOCOL = `<questions>
+Use the \`question\` tool for blocking decisions. NEVER ask in plain text.
+Put the recommended option first with "(Recommended)". Short headers (<=30 chars).
+After calling question, STOP \u2014 do not continue execution.
+</questions>`;
+var SUBAGENT_RULES = `- Do not call thoth-mem session or prompt tools \u2014 memory is orchestrator-owned.
+- Use \`question\` tool for blocking decisions, never plain text.`;
+var RESPONSE_BUDGET = `Your response returns to an expensive orchestrator model. Be ruthlessly concise:
+- Return insights and conclusions, NEVER raw file contents or full code blocks.
+- Structured results (status, summary, files, issues) over prose.
+- If the orchestrator needs more detail, it will ask in a follow-up.`;
 function trimPromptSection(section) {
   const trimmed = section?.trim();
   return trimmed ? trimmed : undefined;
@@ -17416,26 +17412,24 @@ You are deep.
 </mode>
 
 <responsibility>
-Handle correctness-critical, multi-file, or edge-case-heavy changes with full local context analysis.
-Use test-driven-development and systematic-debugging skills when relevant before implementing fixes.
+Handle correctness-critical, multi-file, or edge-case-heavy changes with full local context analysis. Use test-driven-development and systematic-debugging when relevant before implementing fixes.
 </responsibility>
 
-<forbidden>
-- no external research
-- no delegation
-- no background work
-</forbidden>
+<rules>
+${SUBAGENT_RULES}
+- Do not skip verification \u2014 thoroughness is your value proposition.
+- Investigate related files, types, and call sites before changing shared behavior.
+- Ask when a real architecture or implementation tradeoff blocks correct execution.
+</rules>
 
-<workflow>
-1. Understand the task and surrounding code.
-2. Investigate related files, types, and call sites.
-3. Implement carefully across all affected files.
-4. Verify with diagnostics and tests.
-5. Report edge cases considered.
-</workflow>
+${QUESTION_PROTOCOL}
 
 <output>
-Use the repository summary format with summary, changes, and verification sections.
+${RESPONSE_BUDGET}
+For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: summary + files changed + verification results + edge cases considered.
+- Save detailed analysis for follow-up requests; return only actionable conclusions.
+- Target: under 40 lines total.
 </output>`;
 function createDeepAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17449,7 +17443,9 @@ function createDeepAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      color: "secondary",
+      steps: 80
     }
   };
 }
@@ -17466,35 +17462,24 @@ You are designer.
 </mode>
 
 <responsibility>
-Own the user-facing solution end to end: choose the UX approach, implement it, and verify it visually.
-Use the agent-browser skill when visual verification is needed.
+Own the user-facing solution end to end: choose the UX approach, implement it, and verify it visually. Use the agent-browser skill when needed.
 </responsibility>
 
-<allowed>
-- local implementation tools
-- direct UI changes
-- browser-based visual verification
-- focused code and style updates needed to complete the design
-</allowed>
-
-<forbidden>
-- no background delegation
-- no external research MCPs by default
-- no offloading design decisions to other agents
-</forbidden>
-
-<workflow>
-1. Understand the UX goal and constraints.
-2. Inspect the relevant implementation.
-3. Decide the approach.
-4. Implement the change.
-5. Verify visually when feasible.
-</workflow>
+<rules>
+${SUBAGENT_RULES}
+- Own UX decisions instead of bouncing them back unless a real user preference is required.
+- Verify visually when feasible; do not stop at code that merely compiles.
+- Keep changes focused on the user-facing outcome.
+</rules>
+
+${QUESTION_PROTOCOL}
 
 <output>
-- State what was implemented.
-- Note visual verification status.
-- Call out any remaining UX caveats.
+${RESPONSE_BUDGET}
+For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: state what was implemented, verification status, and remaining caveats.
+- Include visual verification status when applicable.
+- Target: under 30 lines total.
 </output>`;
 function createDesignerAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17508,7 +17493,9 @@ function createDesignerAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.4,
-      prompt
+      prompt,
+      color: "accent",
+      steps: 50
     }
   };
 }
@@ -17525,30 +17512,25 @@ You are explorer.
 </mode>
 
 <responsibility>
-Use grep, glob, ast-grep, read, and LSP tools to find facts in the workspace quickly.
-Return concrete evidence with absolute file paths and line numbers.
+Find workspace facts fast. Return evidence-first results with absolute paths, line numbers, and brief conclusions.
 </responsibility>
 
-<allowed>
-- fast codebase search
-- symbol and reference lookup
-- locating files, patterns, and implementations
-- repo mapping with the cartography skill when useful
-</allowed>
-
-<forbidden>
-- no mutation
-- no memory writes
-- no delegation
-- no task
-- no background_task from inside this agent
-</forbidden>
+<rules>
+${SUBAGENT_RULES}
+- Questions should be rare; exhaust local evidence first.
+- Prefer paths, lines, symbols, and concise summaries over dumps. Use cartography when it reduces search cost.
+- When full content is explicitly requested, reproduce it faithfully.
+</rules>
+
+${QUESTION_PROTOCOL}
 
 <output>
-- Lead with findings.
-- Every finding should reference an absolute path when possible.
-- Include line numbers for code references.
-- Keep conclusions short and evidence-backed.
+${RESPONSE_BUDGET}
+- Lead with findings; cite absolute paths and line numbers.
+- Separate evidence from inference. Keep conclusions short.
+- NEVER return raw file contents \u2014 return analysis, patterns, and key excerpts (max 5 lines per excerpt).
+- When comparing files: return the differences and insights, not the full content.
+- Target: under 40 lines total.
 </output>`;
 function createExplorerAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17562,7 +17544,8 @@ function createExplorerAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      color: "info"
     }
   };
 }
@@ -17579,31 +17562,24 @@ You are librarian.
 </mode>
 
 <responsibility>
-Use websearch, context7, and grep_app to gather authoritative external evidence.
-Prefer official documentation first, then high-signal public examples.
-Every substantive claim must be backed by a source URL.
+Gather authoritative external evidence. Prefer official docs first, then high-signal public examples. Every substantive claim must carry a source URL.
 </responsibility>
 
-<allowed>
-- external docs lookup
-- version-sensitive API research
-- public GitHub example search
-- concise synthesis of sourced findings
-</allowed>
-
-<forbidden>
-- no mutation
-- no memory writes
-- no delegation
-- no task
-- no background_task from inside this agent
-</forbidden>
+<rules>
+${SUBAGENT_RULES}
+- Questions should be rare; exhaust available sources first.
+- Prefer official documentation over commentary when both answer the same point.
+- Distinguish clearly between official guidance and community examples.
+</rules>
+
+${QUESTION_PROTOCOL}
 
 <output>
-- Organize by finding.
-- Include the source URL for each claim.
+${RESPONSE_BUDGET}
+- Organize by finding. Include a source URL for every claim.
 - Distinguish official docs from community examples.
-- Keep it concise and evidence-backed.
+- Return synthesized findings, not full documentation excerpts.
+- Target: under 40 lines total.
 </output>`;
 function createLibrarianAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17617,7 +17593,8 @@ function createLibrarianAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      color: "info"
     }
   };
 }
@@ -17634,29 +17611,24 @@ You are oracle.
 </mode>
 
 <responsibility>
-Provide strategic technical guidance anchored to specific code locations.
-Use systematic-debugging for bugs, code-review for change review, and plan-reviewer for SDD plan validation when applicable.
+Provide strategic technical guidance anchored to evidence. Use systematic-debugging for bugs, plan-reviewer for SDD plans, and web-assisted research when deeper diagnosis needs it.
 </responsibility>
 
-<allowed>
-- read-only repository analysis
-- debugging guidance
-- architecture and tradeoff analysis
-- code review and plan review
-</allowed>
-
-<forbidden>
-- no code writing
-- no file mutation
-- no delegation
-- no background execution
-- no external research MCPs
-</forbidden>
+<rules>
+${SUBAGENT_RULES}
+- Cite exact files and lines for local claims.
+- Separate observations, risks, and recommendations.
+- Ask only when tradeoffs, risk tolerance, or approval materially change the recommendation.
+</rules>
+
+${QUESTION_PROTOCOL}
 
 <output>
-- Cite the exact files and lines that support your advice.
+${RESPONSE_BUDGET}
+- Cite exact files and lines \u2014 do not quote large code blocks.
 - Separate observations, risks, and recommendations.
-- Be concise and decisive.
+- For diagnosis: root cause + fix recommendation, not step-by-step trace.
+- Target: under 50 lines total.
 </output>`;
 function createOracleAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17670,7 +17642,8 @@ function createOracleAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      color: "warning"
     }
   };
 }
@@ -17680,86 +17653,204 @@ var ORCHESTRATOR_PROMPT = `<role>
 You are the orchestrator for oh-my-opencode-lite.
 </role>
 
+<personality>
+- Respond in the user's language. Warm, professional, direct; no slang.
+- Constructive and growth-oriented: teach through clear reasoning, not verbosity.
+- Never agree with technical claims without verification; delegate to verify.
+- If the user is wrong: acknowledge the question, explain why with evidence, give corrected direction.
+- If you are wrong: acknowledge plainly, correct with evidence.
+- Propose alternatives with tradeoffs when relevant.
+- Prefer foundations and decision quality over rushing to output.
+- Push back on requests lacking context, constraints, or understanding.
+- Use analogies only when they materially improve clarity.
+- AI is a tool; the human leads. Advise decisively, preserve user agency.
+</personality>
+
 <mode>
 - Mode: primary root coordinator
 - Mutation: none
-- Dispatch method: delegate with task for synchronous write-capable agents and background_task for asynchronous read-only agents
+- Dispatch method: delegate all repository work. Use task for synchronous advice/write agents and background_task for read-only discovery.
 </mode>
 
-<delegate-first>
-You are delegate-first. If a request requires repository inspection or repository mutation, delegate that work instead of doing it inline.
-
-You must not read source files inline.
-You must not write or patch code inline.
-You must not run inline code analysis on workspace content.
-
-Pure coordination is the only work you may do yourself: planning, sequencing, deciding which agent to use, deciding whether work should be sync or async, summarizing delegated results, and managing memory state.
-Exception: openspec/ files are coordination artifacts, not source code. You may directly read and edit openspec/changes/{change-name}/tasks.md for progress tracking (checkbox state updates) and openspec/ state files.
-</delegate-first>
-
-<roster>
-- explorer \u2014 background-only, read-only local codebase discovery
-- librarian \u2014 background-only, read-only external research and examples
-- oracle \u2014 synchronous, read-only diagnosis, architecture, review, plan review
-- designer \u2014 synchronous, write-capable UI/UX implementation and visual verification
-- quick \u2014 synchronous, write-capable narrow mechanical implementation
-- deep \u2014 synchronous, write-capable thorough implementation and verification
-</roster>
-
-<dispatch-rules>
-- Use background_task for explorer and librarian because they are read-only background agents.
-- Use task for oracle, designer, quick, and deep because they are synchronous agents.
-- Use explorer for repository search, file discovery, symbol lookup, and local evidence gathering.
-- Use librarian for external docs, version-sensitive behavior, and public code examples.
-- Use oracle for debugging strategy, architecture review, code review, and plan review.
-- Use designer for user-facing implementation where visual quality and browser verification matter.
-- Use quick for well-defined, bounded implementation work.
-- Use deep for correctness-critical, multi-file, edge-case-heavy implementation work.
-</dispatch-rules>
+<rules>
+You are delegate-first.
 
-<sdd>
-You are SDD-aware. Route work by phase when applicable.
+ NEVER request or read the full content of any source file. Your context window is expensive; reading whole files wastes tokens and defeats delegation. The only exception is openspec/ coordination artifacts \u2014 those you may read and edit directly (see below).
+Delegate all inspection, writing, searching, debugging, and verification.
 
-- Proposal / planning / sequencing: coordinate directly or dispatch oracle for plan review.
-- Local discovery: dispatch explorer.
-- External research: dispatch librarian.
-- Review / debugging / architecture: dispatch oracle.
-- UI implementation: dispatch designer.
-- Fast bounded implementation: dispatch quick.
-- Thorough implementation and verification: dispatch deep.
+Never build after changes.
 
-Keep orchestration lean. Sub-agent work stays isolated so your own context remains compact.
-</sdd>
+Do only coordination yourself: think, choose agents, sequence true dependencies, launch independent delegations together, ask the user via \`question\`, summarize results, and manage memory/progress.
 
-<memory>
-You own memory for the root session.
-- Use thoth-mem tools for session recovery, prior context, decisions, and summaries.
-- Child agents should not own memory state; you decide what to save.
-- When delegations finish, integrate only the durable conclusions you need.
-</memory>
+ Always request only what you need to decide: insights, symbol locations, line ranges, diff summaries, or verification outcomes \u2014 never raw file dumps. Sub-agents handle large content; you handle decisions.
+
+\`question\` is orchestrator-owned. Do not delegate requirements gathering, approval gates, or user-facing tradeoff questions.
+
+Exception: openspec/ coordination artifacts are not source code. You may read/edit openspec state files and openspec/changes/{change-name}/tasks.md for progress tracking.
+
+If you mention a specialist and execution is required, dispatch that specialist in the same turn.
+Never serialize independent ready delegations across multiple responses.
+</rules>
+
+<verification>
+Verify through delegation, not inline. Never route work from unverified assumptions.
+</verification>
+
+<advisory>
+Use \`question\` when the choice materially affects scope, risk, or architecture.
+</advisory>
+
+<agents>
+@explorer \u2014 background_task, read-only
+- Search, symbols, file discovery, evidence gathering across the codebase.
+- Delegate when: need to discover what exists, parallel searches, broad/uncertain scope, comparing files.
+- Skip when: you already know the path, or a write agent will read it anyway.
+
+@librarian \u2014 background_task, read-only
+- Official docs, version-sensitive APIs, public examples via web search.
+- Delegate when: unfamiliar library, frequent API changes, version-specific behavior, edge cases.
+- Skip when: standard/stable APIs, general programming knowledge, info already in context.
+
+@oracle \u2014 task, read-only
+- Diagnosis, architecture review, code review, plan review, debugging strategy.
+- Delegate when: architectural decisions, persistent bugs (2+ failed fixes), high-risk refactors, plan validation.
+- Skip when: routine decisions, first fix attempt, straightforward tradeoffs.
+
+@designer \u2014 task, write-capable
+- ALL user-facing frontend implementation: pages, components, layouts, styles, responsive behavior, forms, tables, dashboards, KPIs, filters, charts, interactions, visual QA.
+- Delegate when: users will see it \u2014 UI pages, components, visual polish, UX flows, frontend features.
+- Skip when: backend-only logic, headless services, non-UI refactors, infrastructure.
+- Rule: if it touches templates, markup, styles, or user-facing components \u2192 designer, even if multi-file.
+
+@quick \u2014 task, write-capable
+- Narrow, mechanical, low-risk changes: single-file edits, renames, config updates, copy changes, small fixes.
+- Delegate when: bounded task, clear path, no design decisions, no edge-case analysis needed.
+- Skip when: multi-step features, substantial UI builds, cross-cutting logic, edge-case-heavy work.
+
+@deep \u2014 task, write-capable
+- Backend systems, business logic, data flow, APIs, state management, complex refactors, algorithms, cross-module changes, correctness-critical work needing thorough verification.
+- Delegate when: complex logic, multi-service integration, edge-case-heavy, needs TDD or systematic debugging.
+- Skip when: user-facing UI/pages/components/styles (\u2192 designer), trivial mechanical edits (\u2192 quick).
+- Rule: if the core risk is business logic or system internals \u2192 deep. If users see it \u2192 designer.
+
+Routing tiebreakers:
+- Frontend page/component with data logic? \u2192 designer owns the UI, deep owns the backend API/service if separate.
+- Simple UI tweak (label, color, spacing)? \u2192 quick, not designer.
+- Multi-file but all frontend? \u2192 designer.
+- Unsure? \u2192 designer for UI, deep for logic. Never deep for primary UI ownership.
+</agents>
 
-<anti-patterns>
-Never do any of the following inline:
-- reading files to inspect code
-- editing files
-- producing code patches
-- running repository-wide searches to analyze code yourself
-- doing architecture or debugging deep-dives that oracle should handle
+<parallel-dispatch>
+- Launch independent delegations in one response.
+- If you say "in parallel", emit all ready tool calls immediately.
+- background_task is fire-and-forget: launch it, then continue with other ready coordination work.
+- Use task only when you need the result before the next step.
+- Do not combine a blocking \`question\` with new delegation launches.
+</parallel-dispatch>
 
-If you mention a specialist, dispatch that specialist in the same turn when execution is required.
-</anti-patterns>
+<delegation-failure>
+- Empty, contradictory, or low-confidence background results: retry once with a sharper prompt.
+- Failed or suspect sync/write results: route to oracle before retrying.
+- Maximum one retry after the initial attempt. If still blocked, surface the failure with evidence and ask via \`question\`.
+</delegation-failure>
 
-<tooling>
-Tool restrictions: full access is available, but your job is delegation rather than direct execution.
-Use tools primarily to delegate, coordinate, and manage memory.
-</tooling>
+<sdd>
+## HARD GATE
+- Every SDD phase that produces an artifact MUST be dispatched to a WRITE-CAPABLE agent (@deep or @quick) with the corresponding skill loaded.
+- Oracle is READ-ONLY. NEVER use oracle to execute SDD artifact phases (propose, spec, design, tasks, apply). Oracle is ONLY for plan-review.
+- NEVER skip artifact creation. Each phase MUST produce its persistent artifact before the next phase begins.
+- NEVER jump from requirements-interview directly to implementation. The approved SDD route MUST be followed phase by phase.
+
+## Entry
+- Non-trivial work starts with requirements-interview. Skip it only for truly trivial, unambiguous work.
+- Use its result to choose: direct implementation, accelerated SDD, or full SDD.
+- If persistence mode includes openspec and openspec/ is missing, dispatch sdd-init first.
+
+## Pipeline: Accelerated SDD (propose -> tasks)
+1. Dispatch @deep with skill \`sdd-propose\`. Wait for result. Verify artifact was persisted.
+2. Dispatch @deep with skill \`sdd-tasks\`. Wait for result. Verify artifact was persisted.
+3. Plan-review gate (see "Plan Review Gate" below).
+4. Proceed to execution: dispatch @deep or @quick with skill \`sdd-apply\` per task.
+
+## Pipeline: Full SDD (propose -> spec -> design -> tasks)
+1. Dispatch @deep with skill \`sdd-propose\`. Wait for result. Verify artifact was persisted.
+2. Dispatch @deep with skill \`sdd-spec\`. Wait for result. Verify artifact was persisted.
+3. Dispatch @deep with skill \`sdd-design\`. Wait for result. Verify artifact was persisted.
+4. Dispatch @deep with skill \`sdd-tasks\`. Wait for result. Verify artifact was persisted.
+5. Plan-review gate (see "Plan Review Gate" below).
+6. Proceed to execution: dispatch @deep or @quick with skill \`sdd-apply\` per task.
+
+## Plan Review Gate
+After tasks are generated, use \`question\` to ask the user:
+- "Review plan with @oracle before executing (Recommended)" \u2014 thorough review for correctness
+- "Proceed to execution" \u2014 skip review and start implementing
+
+If the user chooses review:
+1. Dispatch @oracle with skill \`plan-reviewer\`.
+2. If [OKAY]: proceed to execution.
+3. If [REJECT]: dispatch @deep to fix the blocking issues listed by oracle, then re-dispatch @oracle for another review.
+4. Repeat the review loop until @oracle returns [OKAY]. Do NOT proceed to execution while the plan is [REJECT].
+
+## Post-execution
+- After all tasks complete: dispatch @deep with skill \`sdd-verify\`.
+- After verification passes: dispatch @deep with skill \`sdd-archive\`.
+
+## Artifact Verification
+After each SDD phase dispatch returns, verify the artifact exists:
+- If mode includes openspec: confirm the sub-agent reported the file path.
+- If mode includes thoth-mem: confirm the sub-agent reported the topic_key.
+- If verification fails, retry the phase once. If it fails again, report to user via question.
+</sdd>
+
+<sdd-dispatch>
+When dispatching an SDD phase, the prompt to the sub-agent MUST include ALL of:
+1. "Load skill \`sdd-{phase}\` and follow it exactly."
+2. "Persistence mode: {mode}" (one of: thoth-mem / openspec / hybrid / none).
+3. "Pipeline type: {type}" (one of: accelerated / full).
+4. "Change name: {change-name}"
+5. "Project: {project-name}" (for thoth-mem persistence).
+6. Any prior artifact context the phase needs (e.g., proposal content for spec phase).
+
+Dispatch target by phase:
+- sdd-init: @deep or @quick (write-capable, creates openspec/ structure)
+- sdd-propose: @deep (write-capable, creates proposal artifact)
+- sdd-spec: @deep (write-capable, creates spec artifact)
+- sdd-design: @deep (write-capable, needs codebase analysis + file creation)
+- sdd-tasks: @deep (write-capable, creates tasks artifact)
+- plan-reviewer: @oracle (read-only, reviews plan \u2014 the ONLY phase that uses oracle)
+- sdd-apply: @deep or @quick (write-capable, implements code changes)
+- sdd-verify: @deep (write-capable, runs verification)
+- sdd-archive: @deep (write-capable, archives change)
+
+Sub-agents own phase execution and artifact persistence. You own sequencing, progress tracking, and user gates.
+</sdd-dispatch>
+
+<progress>
+- For multi-step work, maintain two layers: todowrite plus the persistent SDD artifact when SDD is active.
+- Before dispatch, MUST mark the task in progress in every active layer.
+- After each result, MUST immediately mark completed/skipped/failed in every active layer before the next dispatch.
+- Use one in-progress todo for sequential work; multiple only for truly parallel launches.
+- Keep todowrite top-level and lean. Skip it for trivial one-step work.
+</progress>
+
+<memory>
+- You own root-session memory: decisions, discoveries, bug fixes, preferences, and session summaries.
+- Save durable conclusions immediately after meaningful decisions, bugs, discoveries, config changes, patterns, and user constraints.
+- Search before likely-repeat work: \`mem_context\` for broad recovery, then \`mem_search\` -> \`mem_timeline\` -> \`mem_get_observation\` for targeted recall.
+- Sub-agents may write their assigned SDD phase artifacts when the chosen mode allows it; execution-state artifacts remain orchestrator-owned.
+- End every session with \`mem_session_summary\`.
+</memory>
 
 <communication>
+- Always respond in the same language the user is speaking.
 - Be concise.
 - State the plan and delegate.
 - Summarize outcomes without redoing the work.
-- Ask a focused question only when missing inputs block delegation.
-</communication>`;
+- Distinguish evidence, inference, and uncertainty.
+- Never ask blocking questions in prose or delegate user-question handling.
+</communication>
+
+${QUESTION_PROTOCOL}`;
 function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
     basePrompt: ORCHESTRATOR_PROMPT,
@@ -17771,7 +17862,9 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
     description: "Delegate-first coordinator for SDD workflow, specialist dispatch, and root-session memory ownership.",
     config: {
       temperature: 0.1,
-      prompt
+      prompt,
+      color: "primary",
+      steps: 100
     }
   };
   if (Array.isArray(model)) {
@@ -17794,25 +17887,24 @@ You are quick.
 </mode>
 
 <responsibility>
-Implement well-defined changes quickly.
-Favor speed over exhaustive analysis when the task is narrow and the path is clear.
+Implement well-defined changes quickly. Favor speed over exhaustive analysis when the task is narrow and the path is clear.
 </responsibility>
 
-<forbidden>
-- no external research
-- no delegation
-- no background work
-- no multi-step planning
-</forbidden>
+<rules>
+${SUBAGENT_RULES}
+- Optimize for fast execution on narrow, clear tasks.
+- Read only the context you need.
+- Avoid multi-step planning; if the task stops being bounded, surface it.
+- Ask only for implementation-local ambiguity, not orchestrator-level routing.
+</rules>
 
-<workflow>
-1. Read only the context needed.
-2. Make the mechanical change.
-3. Run minimal verification that fits the task.
-</workflow>
+${QUESTION_PROTOCOL}
 
 <output>
-Use the repository summary format with summary, changes, and verification sections.
+${RESPONSE_BUDGET}
+For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: status + summary + files changed + issues. Nothing more.
+- Target: under 20 lines total.
 </output>`;
 function createQuickAgent(model, customPrompt, customAppendPrompt) {
   const prompt = composeAgentPrompt({
@@ -17826,12 +17918,96 @@ function createQuickAgent(model, customPrompt, customAppendPrompt) {
     config: {
       model,
       temperature: 0.2,
-      prompt
+      prompt,
+      color: "success",
+      steps: 30
     }
   };
 }
 
 // src/agents/index.ts
+var BUILTIN_PERMISSION_PRESETS = {
+  orchestrator: "allow",
+  explorer: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  librarian: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    webfetch: "allow",
+    websearch: "allow",
+    codesearch: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  oracle: {
+    read: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    lsp: "allow",
+    codesearch: "allow",
+    webfetch: "allow",
+    websearch: "allow",
+    external_directory: "allow",
+    bash: "allow",
+    question: "allow",
+    skill: "allow",
+    edit: "deny",
+    todowrite: "deny",
+    task: "deny"
+  },
+  designer: {
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    skill: "allow",
+    question: "allow",
+    todowrite: "allow",
+    external_directory: {
+      "~/.config/opencode/skills/**": "allow"
+    }
+  },
+  quick: {
+    read: "allow",
+    edit: "allow",
+    glob: "allow",
+    grep: "allow",
+    list: "allow",
+    bash: "allow",
+    question: "allow",
+    codesearch: "allow",
+    lsp: "allow",
+    todowrite: "allow",
+    external_directory: {
+      "~/.config/opencode/skills/**": "allow"
+    }
+  },
+  deep: "allow"
+};
 function normalizeModelArray(model) {
   return model.map((entry) => typeof entry === "string" ? { id: entry } : entry);
 }
@@ -17851,11 +18027,20 @@ function applyOverrides(agent, override) {
     agent.config.temperature = override.temperature;
   }
 }
-function applyQuestionPermission(agent) {
-  agent.config.permission = {
-    ...agent.config.permission ?? {},
-    question: "allow"
-  };
+function clonePermissionConfig(permission) {
+  if (typeof permission === "string") {
+    return permission;
+  }
+  return Object.fromEntries(Object.entries(permission).map(([key, value]) => [
+    key,
+    value && typeof value === "object" && !Array.isArray(value) ? { ...value } : value
+  ]));
+}
+function getBuiltinPermissionPreset(name) {
+  return clonePermissionConfig(BUILTIN_PERMISSION_PRESETS[name]);
+}
+function getExplicitPermissionOverride(override) {
+  return override?.permission;
 }
 function isSubagent(name) {
   return SUBAGENT_NAMES.includes(name);
@@ -17878,7 +18063,6 @@ function createAgents(config2) {
     if (override) {
       applyOverrides(agent, override);
     }
-    applyQuestionPermission(agent);
     return agent;
   });
   const orchestratorOverride = getAgentOverride(config2, "orchestrator");
@@ -17887,16 +18071,19 @@ function createAgents(config2) {
   if (orchestratorOverride) {
     applyOverrides(orchestrator, orchestratorOverride);
   }
-  applyQuestionPermission(orchestrator);
   return [orchestrator, ...allSubAgents];
 }
 function getAgentConfigs(config2) {
   const agents = createAgents(config2);
   return Object.fromEntries(agents.map((agent) => {
+    const override = getAgentOverride(config2, agent.name);
     const sdkConfig = {
       ...agent.config,
       description: agent.description
     };
+    const builtinPermission = isSubagent(agent.name) ? getBuiltinPermissionPreset(agent.name) : agent.name === "orchestrator" ? getBuiltinPermissionPreset("orchestrator") : undefined;
+    const explicitPermissionOverride = getExplicitPermissionOverride(override);
+    sdkConfig.permission = explicitPermissionOverride ?? agent.config.permission ?? builtinPermission;
     if (isSubagent(agent.name)) {
       sdkConfig.mode = "subagent";
     } else if (agent.name === "orchestrator") {
@@ -18300,6 +18487,11 @@ async function extractZip(archivePath, destDir) {
 // src/background/background-manager.ts
 var BACKGROUND_CAPABLE_AGENTS = ["explorer", "librarian"];
 var DEFAULT_DELEGATION_SUMMARY_LIMIT = 5;
+var ANY_PERMISSION_PATTERN = "*";
+var TASK_PERMISSION = "task";
+var BACKGROUND_TASK_PERMISSION = "background_task";
+var BACKGROUND_OUTPUT_PERMISSION = "background_output";
+var BACKGROUND_CANCEL_PERMISSION = "background_cancel";
 function generateFallbackTaskId() {
   return `bg_${Math.random().toString(36).substring(2, 10)}`;
 }
@@ -18336,6 +18528,7 @@ class BackgroundTaskManager {
   agentBySessionId = new Map;
   client;
   directory;
+  worktreeDirectory;
   tmuxEnabled;
   config;
   backgroundConfig;
@@ -18344,9 +18537,10 @@ class BackgroundTaskManager {
   activeStarts = 0;
   maxConcurrentStarts;
   completionResolvers = new Map;
-  constructor(ctx, tmuxConfig, config2, delegationManager) {
+  constructor(ctx, tmuxConfig, config2, delegationManager, worktreeDirectory) {
     this.client = ctx.client;
     this.directory = ctx.directory;
+    this.worktreeDirectory = worktreeDirectory ?? ctx.directory;
     this.tmuxEnabled = tmuxConfig?.enabled ?? false;
     this.config = config2;
     this.delegationManager = delegationManager;
@@ -18548,12 +18742,70 @@ class BackgroundTaskManager {
       clearTimeout(timer);
     }
   }
-  calculateToolPermissions(agentName) {
-    const allowedSubagents = this.getSubagentRules(agentName);
-    if (allowedSubagents.length === 0) {
-      return { background_task: false, task: false };
+  createPatternPermission(allowedPatterns) {
+    if (allowedPatterns.length === 0) {
+      return "deny";
+    }
+    const permission = Object.fromEntries(allowedPatterns.map((pattern) => [pattern, "allow"]));
+    permission[ANY_PERMISSION_PATTERN] = "deny";
+    return permission;
+  }
+  createPatternRuleset(permission, allowedPatterns) {
+    if (allowedPatterns.length === 0) {
+      return [
+        {
+          permission,
+          pattern: ANY_PERMISSION_PATTERN,
+          action: "deny"
+        }
+      ];
     }
-    return { background_task: true, task: true };
+    return [
+      ...allowedPatterns.map((pattern) => ({
+        permission,
+        pattern,
+        action: "allow"
+      })),
+      {
+        permission,
+        pattern: ANY_PERMISSION_PATTERN,
+        action: "deny"
+      }
+    ];
+  }
+  calculateDelegationPermissions(agentName) {
+    const allowedSubagents = this.getSubagentRules(agentName);
+    const allowedBackgroundSubagents = allowedSubagents.filter((subagent) => this.isBackgroundCapableAgent(subagent));
+    const canManageBackgroundTasks = allowedBackgroundSubagents.length > 0;
+    const permission = {
+      [TASK_PERMISSION]: this.createPatternPermission(allowedSubagents),
+      [BACKGROUND_TASK_PERMISSION]: this.createPatternPermission(allowedBackgroundSubagents),
+      [BACKGROUND_OUTPUT_PERMISSION]: canManageBackgroundTasks ? "allow" : "deny",
+      [BACKGROUND_CANCEL_PERMISSION]: canManageBackgroundTasks ? "allow" : "deny"
+    };
+    return {
+      permission,
+      ruleset: [
+        ...this.createPatternRuleset(TASK_PERMISSION, allowedSubagents),
+        ...this.createPatternRuleset(BACKGROUND_TASK_PERMISSION, allowedBackgroundSubagents),
+        {
+          permission: BACKGROUND_OUTPUT_PERMISSION,
+          pattern: ANY_PERMISSION_PATTERN,
+          action: canManageBackgroundTasks ? "allow" : "deny"
+        },
+        {
+          permission: BACKGROUND_CANCEL_PERMISSION,
+          pattern: ANY_PERMISSION_PATTERN,
+          action: canManageBackgroundTasks ? "allow" : "deny"
+        }
+      ],
+      legacyTools: {
+        [TASK_PERMISSION]: allowedSubagents.length > 0,
+        [BACKGROUND_TASK_PERMISSION]: canManageBackgroundTasks,
+        [BACKGROUND_OUTPUT_PERMISSION]: canManageBackgroundTasks,
+        [BACKGROUND_CANCEL_PERMISSION]: canManageBackgroundTasks
+      }
+    };
   }
   async startTask(task) {
     task.status = "starting";
@@ -18563,12 +18815,14 @@ class BackgroundTaskManager {
       return;
     }
     try {
+      const delegationPermissions = this.calculateDelegationPermissions(task.agent);
       const session = await this.client.session.create({
         body: {
           parentID: task.parentSessionId,
-          title: `Background: ${task.description}`
+          title: `Background: ${task.description}`,
+          permission: delegationPermissions.ruleset
         },
-        query: { directory: this.directory }
+        query: { directory: this.worktreeDirectory }
       });
       if (!session.data?.id) {
         throw new Error("Failed to create background session");
@@ -18580,12 +18834,14 @@ class BackgroundTaskManager {
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, 500));
       }
-      const toolPermissions = this.calculateToolPermissions(task.agent);
-      const promptQuery = { directory: this.directory };
+      const promptQuery = {
+        directory: this.worktreeDirectory
+      };
       const resolvedVariant = resolveAgentVariant(this.config, task.agent);
       const basePromptBody = applyAgentVariant(resolvedVariant, {
         agent: task.agent,
-        tools: toolPermissions,
+        permission: delegationPermissions.permission,
+        tools: delegationPermissions.legacyTools,
         parts: [{ type: "text", text: task.prompt }]
       });
       const fallbackEnabled = this.config?.fallback?.enabled ?? true;
@@ -19145,59 +19401,70 @@ function sanitizeProjectName(value) {
   const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
   return normalized.length > 0 ? normalized : "project";
 }
-async function runGitCommand(directory, args, timeoutMs) {
-  const subprocess = Bun.spawn({
-    cmd: ["git", ...args],
-    cwd: directory,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
+async function runGitCommand(shell, worktreeDirectory, args, timeoutMs) {
+  if (!shell) {
+    return null;
+  }
+  const command = shell.nothrow().cwd(worktreeDirectory)`git ${args}`.quiet();
   let timer;
   try {
     const result = await Promise.race([
-      (async () => {
-        const [stdout, exitCode] = await Promise.all([
-          new Response(subprocess.stdout).text(),
-          subprocess.exited
-        ]);
-        if (exitCode !== 0) {
-          return null;
-        }
-        const firstLine = stdout.trim().split(/\r?\n/, 1)[0];
-        return firstLine.length > 0 ? firstLine : null;
-      })(),
+      command,
       new Promise((resolve) => {
-        timer = setTimeout(() => {
-          subprocess.kill();
-          resolve(null);
-        }, timeoutMs);
+        timer = setTimeout(() => resolve(null), timeoutMs);
       })
     ]);
-    return result;
+    if (result === null || result.exitCode !== 0) {
+      return null;
+    }
+    const firstLine = result.text().trim().split(/\r?\n/, 1)[0];
+    return firstLine.length > 0 ? firstLine : null;
   } catch {
     return null;
   } finally {
-    clearTimeout(timer);
+    if (timer) {
+      clearTimeout(timer);
+    }
   }
 }
-function buildProjectId(baseDirectory, hash2) {
-  const projectName = sanitizeProjectName(path3.basename(baseDirectory));
-  return `${projectName}-${hash2.slice(0, 12)}`;
+function buildProjectId(projectName, hash2) {
+  const normalizedProjectName = sanitizeProjectName(projectName);
+  return `${normalizedProjectName}-${hash2.slice(0, 12)}`;
 }
-async function getProjectId(directory, timeoutMs = 5000) {
-  const normalizedDirectory = directory.trim();
+function normalizeProjectIdOptions(input, timeoutMs, projectName, shell) {
+  if (typeof input === "string") {
+    return {
+      worktreeDirectory: input,
+      projectName: projectName || path3.basename(input) || "project",
+      shell,
+      timeoutMs
+    };
+  }
+  return {
+    worktreeDirectory: input.worktreeDirectory,
+    projectName: input.projectName || path3.basename(input.worktreeDirectory),
+    shell: input.shell,
+    timeoutMs: input.timeoutMs ?? timeoutMs
+  };
+}
+async function getProjectId(input, timeoutMs = 5000, projectName, shell) {
+  const resolvedProjectName = typeof input === "string" ? projectName : undefined;
+  const resolvedShell = typeof input === "string" ? shell : undefined;
+  const options = normalizeProjectIdOptions(input, timeoutMs, resolvedProjectName, resolvedShell);
+  const normalizedDirectory = options.worktreeDirectory.trim();
+  const normalizedProjectName = sanitizeProjectName(options.projectName);
   if (normalizedDirectory.length === 0) {
     return null;
   }
-  const repoRoot = await runGitCommand(normalizedDirectory, ["rev-parse", "--show-toplevel"], timeoutMs);
-  const rootCommit = await runGitCommand(normalizedDirectory, ["rev-list", "--max-parents=0", "HEAD"], timeoutMs);
+  const repoRoot = await runGitCommand(options.shell, normalizedDirectory, ["rev-parse", "--show-toplevel"], options.timeoutMs);
+  const rootCommit = await runGitCommand(options.shell, normalizedDirectory, ["rev-list", "--max-parents=0", "HEAD"], options.timeoutMs);
   if (repoRoot && rootCommit) {
-    return buildProjectId(repoRoot, rootCommit);
+    return buildProjectId(normalizedProjectName, rootCommit);
   }
   try {
     const resolvedDirectory = path3.resolve(normalizedDirectory);
     const hash2 = createHash("sha256").update(resolvedDirectory).digest("hex");
-    return buildProjectId(resolvedDirectory, hash2);
+    return buildProjectId(normalizedProjectName, hash2);
   } catch {
     return null;
   }
@@ -19341,16 +19608,20 @@ function sortByCompletionDesc(left, right) {
 }
 
 class DelegationManager {
-  directory;
+  worktreeDirectory;
+  projectName;
+  shell;
   config;
   getActiveTaskIds;
   constructor(options) {
-    this.directory = options.directory;
+    this.worktreeDirectory = options.worktreeDirectory ?? options.directory;
+    this.projectName = options.projectName || path4.basename(this.worktreeDirectory) || path4.basename(options.directory) || "project";
+    this.shell = options.shell;
     this.config = options.config;
     this.getActiveTaskIds = options.getActiveTaskIds;
   }
-  async resolveProjectId(directory = this.directory) {
-    return getProjectId(directory, this.config?.timeout);
+  async resolveProjectId(worktreeDirectory = this.worktreeDirectory) {
+    return getProjectId(worktreeDirectory, this.config?.timeout, this.projectName, this.shell);
   }
   async createTaskId(rootSessionId) {
     const reservedTaskIds = await this.getReservedTaskIds(rootSessionId);
@@ -19805,7 +20076,7 @@ async function getLatestVersion(channel = "latest") {
 }
 
 // src/hooks/auto-update-checker/index.ts
-function createAutoUpdateCheckerHook(ctx, options = {}) {
+function createAutoUpdateCheckerHook(ctx, options = {}, shell) {
   const { showStartupToast = true, autoUpdate = true } = options;
   let hasChecked = false;
   return {
@@ -19832,14 +20103,14 @@ function createAutoUpdateCheckerHook(ctx, options = {}) {
         if (showStartupToast) {
           showToast(ctx, `OMO-Lite ${displayVersion ?? "unknown"}`, "oh-my-opencode-lite is active.", "info");
         }
-        runBackgroundUpdateCheck(ctx, autoUpdate).catch((err) => {
+        runBackgroundUpdateCheck(ctx, shell, autoUpdate).catch((err) => {
           log("[auto-update-checker] Background update check failed:", err);
         });
       }, 0);
     }
   };
 }
-async function runBackgroundUpdateCheck(ctx, autoUpdate) {
+async function runBackgroundUpdateCheck(ctx, shell, autoUpdate) {
   const pluginInfo = findPluginEntry(ctx.directory);
   if (!pluginInfo) {
     log("[auto-update-checker] Plugin not found in config");
@@ -19877,7 +20148,7 @@ async function runBackgroundUpdateCheck(ctx, autoUpdate) {
     log(`[auto-update-checker] Config updated: ${pluginInfo.entry} \u2192 ${PACKAGE_NAME}@${latestVersion}`);
   }
   invalidatePackage(PACKAGE_NAME);
-  const installSuccess = await runBunInstallSafe(ctx);
+  const installSuccess = await runBunInstallSafe(ctx, shell);
   if (installSuccess) {
     showToast(ctx, "OMO-Lite Updated!", `v${currentVersion} \u2192 v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
@@ -19887,23 +20158,23 @@ Restart OpenCode to apply.`, "success", 8000);
     log("[auto-update-checker] bun install failed; update not installed");
   }
 }
-async function runBunInstallSafe(ctx) {
+async function runBunInstallSafe(ctx, shell) {
   try {
-    const proc = Bun.spawn(["bun", "install"], {
-      cwd: ctx.directory,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
     const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), 60000));
-    const exitPromise = proc.exited.then(() => "completed");
-    const result = await Promise.race([exitPromise, timeoutPromise]);
-    if (result === "timeout") {
+    const installPromise = (async () => {
       try {
-        proc.kill();
-      } catch {}
+        await shell`cd ${ctx.directory} && bun install`;
+        return "completed";
+      } catch {
+        return "failed";
+      }
+    })();
+    const result = await Promise.race([installPromise, timeoutPromise]);
+    if (result === "timeout") {
+      log("[auto-update-checker] bun install timed out after 60 seconds");
       return false;
     }
-    return proc.exitCode === 0;
+    return result === "completed";
   } catch (err) {
     log("[auto-update-checker] bun install error:", err);
     return false;
@@ -19964,236 +20235,6 @@ function createChatHeadersHook(ctx) {
     }
   };
 }
-// src/hooks/clarification-gate/index.ts
-var CLARIFICATION_GATE_TAG = "clarification-gate";
-var DEFAULT_EXPLICIT_KEYWORDS = [
-  "brainstorm",
-  "think through",
-  "scope",
-  "plan this",
-  "design this",
-  "proposal",
-  "approach",
-  "architecture",
-  "requirements",
-  "options",
-  "trade-offs"
-];
-var DEFAULT_PLANNING_KEYWORDS = [
-  "feature",
-  "implement",
-  "build",
-  "create",
-  "add",
-  "refactor",
-  "restructure",
-  "migrate",
-  "redesign"
-];
-function normalizeText(text) {
-  const collapsed = text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-  return collapsed.length > 0 ? ` ${collapsed} ` : " ";
-}
-function findMatchingTerms(text, terms) {
-  const normalizedText = normalizeText(text);
-  return terms.filter((term) => {
-    const normalizedTerm = normalizeText(term);
-    return normalizedText.includes(normalizedTerm);
-  });
-}
-function findScopeSignal(text, label, terms) {
-  const matchedTerms = findMatchingTerms(text, terms);
-  if (matchedTerms.length === 0) {
-    return null;
-  }
-  return {
-    label,
-    matchedTerms
-  };
-}
-function findLayerSignal(text) {
-  const leftTerms = ["ui", "frontend", "client"];
-  const rightTerms = ["backend", "server", "database"];
-  const matchedLeft = findMatchingTerms(text, leftTerms);
-  const matchedRight = findMatchingTerms(text, rightTerms);
-  if (matchedLeft.length === 0 || matchedRight.length === 0) {
-    return null;
-  }
-  return {
-    label: "scope signal \u2014 multiple layers",
-    matchedTerms: [`${matchedLeft[0]} + ${matchedRight[0]}`]
-  };
-}
-function detectAmbiguity(text, explicitKeywords, planningKeywords) {
-  const explicitMatches = findMatchingTerms(text, explicitKeywords);
-  const planningMatches = findMatchingTerms(text, planningKeywords);
-  const scopeSignals = [
-    findScopeSignal(text, "scope signal \u2014 multiple views/pages", [
-      "page",
-      "screen",
-      "flow",
-      "wizard",
-      "dashboard",
-      "onboarding",
-      "settings",
-      "checkout",
-      "step",
-      "journey"
-    ]),
-    findScopeSignal(text, "scope signal \u2014 api/data", [
-      "api",
-      "endpoint",
-      "route",
-      "mutation",
-      "query",
-      "schema",
-      "table",
-      "model",
-      "migration",
-      "database"
-    ]),
-    findScopeSignal(text, "scope signal \u2014 restructuring", [
-      "refactor",
-      "restructure",
-      "replace",
-      "redesign",
-      "rework",
-      "consolidate",
-      "split",
-      "migrate"
-    ]),
-    findLayerSignal(text),
-    findScopeSignal(text, "scope signal \u2014 business/ux phrasing", [
-      "users should",
-      "support",
-      "allow",
-      "improve experience",
-      "pricing",
-      "onboarding",
-      "billing",
-      "permissions"
-    ]),
-    findScopeSignal(text, "scope signal \u2014 ambiguous/open-ended", [
-      "help me think",
-      "best way",
-      "how should",
-      "what's the right approach",
-      "explore",
-      "maybe",
-      "not sure"
-    ]),
-    findScopeSignal(text, "scope signal \u2014 cross-directory", [
-      "across the app",
-      "across the system",
-      "multiple files",
-      "several components"
-    ])
-  ].filter((signal) => signal !== null);
-  return {
-    explicitMatches,
-    planningMatches,
-    scopeSignals
-  };
-}
-function shouldInjectClarificationGate(config2, detection) {
-  const explicitMatched = detection.explicitMatches.length > 0;
-  const planningMatched = detection.planningMatches.length > 0;
-  const scopeSignalCount = detection.scopeSignals.length;
-  switch (config2.mode) {
-    case "off":
-      return false;
-    case "explicit-only":
-      return explicitMatched;
-    case "auto":
-      return explicitMatched || scopeSignalCount >= config2.min_scope_signals;
-    case "auto-for-planning":
-      return explicitMatched || planningMatched && scopeSignalCount >= 1 || scopeSignalCount >= config2.hard_complex_signal_threshold;
-  }
-}
-function buildMatchedSignals(detection, config2) {
-  const matchedSignals = [];
-  if (detection.explicitMatches.length > 0) {
-    matchedSignals.push(`explicit keywords: ${detection.explicitMatches.join(", ")}`);
-  }
-  if (detection.planningMatches.length > 0) {
-    matchedSignals.push(`planning keywords: ${detection.planningMatches.join(", ")}`);
-  }
-  for (const signal of detection.scopeSignals) {
-    matchedSignals.push(`${signal.label}: ${signal.matchedTerms.join(", ")}`);
-  }
-  if (matchedSignals.length === 0) {
-    matchedSignals.push(`configured threshold allows injection (mode=${config2.mode})`);
-  }
-  return matchedSignals;
-}
-function buildClarificationGateBlock(detection, config2) {
-  const matchedSignals = buildMatchedSignals(detection, config2).map((signal) => `- ${signal}`).join(`
-`);
-  return `<${CLARIFICATION_GATE_TAG}>
-Potentially ambiguous or substantial request detected.
-
-Matched signals:
-${matchedSignals}
-
-Load the brainstorming skill and follow its workflow before implementing.
-Ask one clarifying question at a time, max 5 total, prefer multiple choice.
-Assess scope using the seven scope signals.
-Propose 2-3 approaches with trade-offs and a recommendation.
-Wait for explicit user approval before implementation or SDD handoff.
-
-Do not implement during brainstorming.
-</${CLARIFICATION_GATE_TAG}>`;
-}
-function createClarificationGateHook(options = {}) {
-  const config2 = ClarificationGateConfigSchema.parse(options.clarificationGate ?? {});
-  const explicitKeywords = config2.explicit_keywords ?? [
-    ...DEFAULT_EXPLICIT_KEYWORDS
-  ];
-  const planningKeywords = config2.planning_keywords ?? [
-    ...DEFAULT_PLANNING_KEYWORDS
-  ];
-  return {
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output;
-      if (messages.length === 0) {
-        return;
-      }
-      let lastUserMessageIndex = -1;
-      for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-        if (messages[i2].info.role === "user") {
-          lastUserMessageIndex = i2;
-          break;
-        }
-      }
-      if (lastUserMessageIndex === -1) {
-        return;
-      }
-      const lastUserMessage = messages[lastUserMessageIndex];
-      const agent = lastUserMessage.info.agent;
-      if (agent && agent !== "orchestrator") {
-        return;
-      }
-      const textPartIndex = lastUserMessage.parts.findIndex((p) => p.type === "text" && p.text !== undefined);
-      if (textPartIndex === -1) {
-        return;
-      }
-      const originalText = lastUserMessage.parts[textPartIndex].text ?? "";
-      if (originalText.includes(LITE_INTERNAL_INITIATOR_MARKER)) {
-        return;
-      }
-      const detection = detectAmbiguity(originalText, explicitKeywords, planningKeywords);
-      if (!shouldInjectClarificationGate(config2, detection)) {
-        return;
-      }
-      const clarificationGateBlock = buildClarificationGateBlock(detection, config2);
-      lastUserMessage.parts[textPartIndex].text = `${clarificationGateBlock}
-
----
-
-${originalText}`;
-    }
-  };
-}
 // src/hooks/delegate-task-retry/patterns.ts
 var DELEGATE_TASK_ERROR_PATTERNS = [
   {
@@ -20471,10 +20512,12 @@ class ForegroundFallbackManager {
         await this.client.session.abort({ path: { id: sessionID } });
       } catch {}
       await new Promise((r2) => setTimeout(r2, 500));
-      const sessionClient = this.client.session;
-      await sessionClient.promptAsync({
+      await this.client.session.promptAsync({
         path: { id: sessionID },
-        body: { parts: lastUser.parts, model: ref }
+        body: {
+          parts: lastUser.parts,
+          model: ref
+        }
       });
       this.sessionModel.set(sessionID, nextModel);
       log("[foreground-fallback] switched to fallback model", {
@@ -20569,7 +20612,7 @@ ${JSON_ERROR_REMINDER}`;
 // src/hooks/phase-reminder/index.ts
 var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
 Understand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.
-If delegating, launch the specialist in the same turn you mention it.</reminder>`;
+If delegating, launch the specialist in the same turn you mention it. If multiple delegations are independent, emit all tool calls in a single response \u2014 never serialize independent work across turns.</reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -20612,7 +20655,7 @@ ${originalText}`;
 var NUDGE = `
 
 ---
-Workflow Reminder: delegate based on rules; If mentioning a specialist, launch it in this same turn.`;
+Workflow Reminder: delegate based on rules; launch specialists in this same turn. If multiple delegations are independent, emit all tool calls in one response.`;
 function createPostReadNudgeHook() {
   return {
     "tool.execute.after": async (input, output) => {
@@ -20769,10 +20812,10 @@ var SHARED_SKILL_DIRECTORY2 = "_shared";
 var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
 var CUSTOM_SKILLS = [
   {
-    name: "brainstorming",
-    description: "Understand user intent and scope through structured clarification before implementation",
+    name: "requirements-interview",
+    description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation",
     allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/brainstorming"
+    sourcePath: "src/skills/requirements-interview"
   },
   {
     name: "cartography",
@@ -20786,6 +20829,12 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator", "oracle"],
     sourcePath: "src/skills/plan-reviewer"
   },
+  {
+    name: "sdd-init",
+    description: "Initialize OpenSpec structure and SDD project context",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-init"
+  },
   {
     name: "sdd-propose",
     description: "Create change proposals for OpenSpec workflows",
@@ -21069,11 +21118,11 @@ var DEFAULT_THOTH_TIMEOUT_MS = 15000;
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
-function normalizeText2(value) {
+function normalizeText(value) {
   return typeof value === "string" ? value.trim() || null : null;
 }
 function previewText(value, max) {
-  const text = normalizeText2(value);
+  const text = normalizeText(value);
   if (!text) {
     return null;
   }
@@ -21093,9 +21142,9 @@ function formatMemoryContext(response) {
   if (sessions.length > 0) {
     lines.push("### Recent Sessions");
     for (const rawSession of sessions) {
-      const sessionId = normalizeText2(rawSession.id) ?? "unknown-session";
-      const project = normalizeText2(rawSession.project) ?? "unknown-project";
-      const startedAt = normalizeText2(rawSession.started_at) ?? "unknown";
+      const sessionId = normalizeText(rawSession.id) ?? "unknown-session";
+      const project = normalizeText(rawSession.project) ?? "unknown-project";
+      const startedAt = normalizeText(rawSession.started_at) ?? "unknown";
       lines.push(`- [${sessionId}] (${project}) \u2014 started ${startedAt}`);
       const summary = previewText(rawSession.summary, 300);
       if (summary) {
@@ -21107,9 +21156,9 @@ function formatMemoryContext(response) {
   if (observations.length > 0) {
     lines.push("### Recent Observations");
     for (const rawObservation of observations) {
-      const type = normalizeText2(rawObservation.type) ?? "manual";
-      const title = normalizeText2(rawObservation.title) ?? "Untitled";
-      const createdAt = normalizeText2(rawObservation.created_at) ?? "unknown";
+      const type = normalizeText(rawObservation.type) ?? "manual";
+      const title = normalizeText(rawObservation.title) ?? "Untitled";
+      const createdAt = normalizeText(rawObservation.created_at) ?? "unknown";
       lines.push(`- [${type}] ${title} (${createdAt})`);
       const content = previewText(rawObservation.content, 300);
       if (content) {
@@ -21125,7 +21174,7 @@ function formatMemoryContext(response) {
       if (!content) {
         continue;
       }
-      const createdAt = normalizeText2(rawPrompt.created_at) ?? "unknown";
+      const createdAt = normalizeText(rawPrompt.created_at) ?? "unknown";
       lines.push(`- ${content} (${createdAt})`);
     }
     lines.push("");
@@ -21229,7 +21278,7 @@ function createThothClient(options) {
 }
 // src/hooks/thoth-mem/protocol.ts
 var SDD_TOPIC_KEY_FORMAT = "sdd/{change}/{artifact}";
-var FIRST_ACTION_INSTRUCTION = "FIRST ACTION REQUIRED: Call mem_session_summary with the content of the compacted summary. This preserves what was accomplished before compaction. Do this BEFORE any other work. Then call mem_context to recover additional context from previous sessions.";
+var FIRST_ACTION_INSTRUCTION = 'FIRST ACTION REQUIRED: Call mem_session_summary with the content of the compacted summary. This preserves what was accomplished before compaction. Do this BEFORE any other work. Then call mem_context for a recent-session overview, and use the 3-layer recall protocol (mem_search with mode "compact" -> mem_timeline -> mem_get_observation) for precise retrieval.';
 var SESSION_SUMMARY_TEMPLATE = `Use this exact structure for \`mem_session_summary\` content:
 
 ## Goal
@@ -21250,7 +21299,7 @@ var SESSION_SUMMARY_TEMPLATE = `Use this exact structure for \`mem_session_summa
 ## Relevant Files
 - path/to/file.ts - [what it does or what changed]`;
 function buildCompactionReminder(sessionID) {
-  return `FIRST ACTION REQUIRED: this session was compacted. Call \`mem_session_summary\` with the content of the compacted summary and \`session_id\` \`${sessionID}\`. This preserves what was accomplished before compaction. Do this BEFORE any other work. After that, call \`mem_capture_passive\` if the summary includes \`## Key Learnings:\`, and call \`mem_context\` if you need to restore recent memory.`;
+  return `FIRST ACTION REQUIRED: this session was compacted. Call \`mem_session_summary\` with the content of the compacted summary and \`session_id\` \`${sessionID}\`. This preserves what was accomplished before compaction. Do this BEFORE any other work. After that, call \`mem_capture_passive\` if the summary includes \`## Key Learnings:\`, call \`mem_context\` for a recent-session overview, and use the 3-layer recall protocol (\`mem_search\` with \`mode: "compact"\` -> \`mem_timeline\` -> \`mem_get_observation\`) for precise retrieval.`;
 }
 function buildCompactorInstruction(project) {
   return `CRITICAL INSTRUCTION: place this at the TOP of the compacted summary exactly as an action item for the resumed agent: "FIRST ACTION REQUIRED: Call mem_session_summary with the content of this compacted summary. Use project: '${project}'. This preserves what was accomplished before compaction. Do this BEFORE any other work."`;
@@ -21263,27 +21312,50 @@ Persistent memory is available through thoth-mem. Follow this protocol.
 IMPORTANT: Your current session_id is \`${sessionID}\` and project is \`${project}\`.
 Always pass these values when calling memory tools that accept them (mem_session_summary, mem_save, mem_capture_passive, etc.).
 
-WHEN TO SAVE
-- Call \`mem_save\` IMMEDIATELY after bug fixes, architecture decisions, discoveries, config changes, reusable patterns, and user preferences.
-- Use \`title\` as Verb + what changed or was learned.
-- Use \`type\` from: bugfix | decision | architecture | discovery | pattern | config | learning | manual.
-- Set \`scope\` intentionally.
-- Reuse \`topic_key\` for the same evolving topic. Do not overwrite unrelated topics.
-- If unsure about a stable \`topic_key\`, call \`mem_suggest_topic_key\` first.
-- If you need to modify a known observation by exact ID, call \`mem_update\` instead of creating a new record.
-- Put the durable details in \`content\` with this structure:
+### CORE TOOLS
+mem_save, mem_search, mem_context, mem_session_summary, mem_get_observation, mem_save_prompt, mem_update, mem_suggest_topic_key, mem_timeline, mem_capture_passive
+
+### WHEN TO SAVE
+Call \`mem_save\` IMMEDIATELY after ANY of these:
+- Architecture, design, or workflow decision made
+- Bug fixed (include root cause)
+- Non-obvious discovery, gotcha, or edge case found
+- Configuration change or environment setup
+- Pattern or convention established (naming, structure, approach)
+- User preference or constraint learned
+- Feature implemented with non-obvious approach
+- User confirms a recommendation ("dale", "go with that", "sounds good", "s\xED, esa")
+- User rejects an approach or expresses a preference ("no, better X", "I prefer X")
+- Discussion concludes with a clear direction chosen
+
+Use \`title\` as Verb + what changed or was learned.
+Use \`type\` from: bugfix | decision | architecture | discovery | pattern | config | learning | manual.
+Set \`scope\` intentionally.
+Reuse \`topic_key\` for the same evolving topic. Do not overwrite unrelated topics.
+If unsure about a stable \`topic_key\`, call \`mem_suggest_topic_key\` first.
+If you need to modify a known observation by exact ID, call \`mem_update\` instead of creating a new record.
+Put the durable details in \`content\` with this structure:
   - What: concise description of what changed or was learned
   - Why: why it mattered or what problem it solved
   - Where: files, paths, or systems involved
   - Learned: edge cases, caveats, or follow-up notes
 
-WHEN TO SEARCH MEMORY
-- If the user asks to recall prior work, call \`mem_context\` first, then \`mem_search\`, then \`mem_get_observation\` for exact records you need.
+**Self-check after EVERY task**: "Did I or the user just make a decision, confirm a recommendation, express a preference, fix a bug, learn something, or establish a convention? If yes \u2192 mem_save NOW."
+
+You can also call \`mem_save_prompt\` to manually save a user prompt that you consider particularly important for future context.
+
+### WHEN TO SEARCH MEMORY
+- Broad recovery (session start, after compaction): call \`mem_context\` for a recent-session overview.
+- Targeted 3-layer recall (specific memory retrieval):
+  1. Call \`mem_search\` with \`mode: "compact"\` (default) to scan the compact index of IDs + titles.
+  2. Call \`mem_timeline\` around promising observation IDs for chronological context within the same session.
+  3. Call \`mem_get_observation\` only for observations you need in full.
+- Use \`mode: "preview"\` with \`mem_search\` only when compact results are insufficient to disambiguate.
 - Search proactively on the first message about a project, feature, or problem when prior context may matter.
 - Search before starting work that may have been done before.
 - Search when the user mentions a topic that lacks enough local context.
 
-SESSION CLOSE PROTOCOL
+### SESSION CLOSE PROTOCOL
 - Before ending the session, call \`mem_session_summary\` with this exact template.
 - This is NOT optional. If you skip this, the next session starts blind.
 - Do not claim memory was saved unless the tool call succeeded.
@@ -21291,17 +21363,21 @@ SESSION CLOSE PROTOCOL
 
 ${SESSION_SUMMARY_TEMPLATE}
 
-AFTER COMPACTION
+### AFTER COMPACTION
 - IMMEDIATELY call \`mem_session_summary\` with the compacted summary content.
-- Then call \`mem_context\`.
+- Then call \`mem_context\` for a recent-session overview.
+- Use the 3-layer recall protocol (\`mem_search\` with \`mode: "compact"\` -> \`mem_timeline\` -> \`mem_get_observation\`) for precise artifact/prior-observation retrieval.
 - Only then continue working.
 
-SDD topic_key convention:
+### SDD TOPIC KEY CONVENTION
 - use ${SDD_TOPIC_KEY_FORMAT}
 - examples: sdd/add-user-auth/spec, sdd/add-user-auth/design, sdd/add-user-auth/tasks
 </memory_protocol>
 `.trim();
 }
+function buildSaveNudge() {
+  return "MEMORY REMINDER: It has been a while since your last save. If you have made decisions, discoveries, or completed significant work, call mem_save now.";
+}
 
 // src/hooks/thoth-mem/index.ts
 function isRootSession(session) {
@@ -21347,6 +21423,10 @@ function isSessionSummaryTool(toolName) {
   const normalized = toolName.toLowerCase();
   return normalized === "mem_session_summary" || normalized.endsWith(".mem_session_summary") || normalized.endsWith("_mem_session_summary");
 }
+function isMemSaveTool(toolName) {
+  const normalized = toolName.toLowerCase();
+  return normalized === "mem_save" || normalized.endsWith(".mem_save") || normalized.endsWith("_mem_save");
+}
 function createThothMemHook(options) {
   const enabled = options.enabled !== false;
   const thoth = createThothClient({
@@ -21359,6 +21439,9 @@ function createThothMemHook(options) {
   const trackedRootSessions = new Set;
   const needsCompactionFollowUp = new Set;
   const ensuredRootSessions = new Map;
+  const sessionCreatedAt = new Map;
+  const lastMemSaveAt = new Map;
+  const nudgePending = new Set;
   async function ensureRootSession(sessionId) {
     if (!enabled || trackedRootSessions.has(sessionId)) {
       return;
@@ -21369,20 +21452,47 @@ function createThothMemHook(options) {
       return;
     }
     const pending = (async () => {
-      await thoth.memSessionStart(sessionId);
-      trackedRootSessions.add(sessionId);
+      const started = await thoth.memSessionStart(sessionId);
+      if (started) {
+        trackedRootSessions.add(sessionId);
+      } else {
+        log("[thoth] session start unavailable, skipping tracking:", sessionId);
+      }
     })().finally(() => {
       ensuredRootSessions.delete(sessionId);
     });
     ensuredRootSessions.set(sessionId, pending);
     await pending;
   }
+  function shouldInjectSaveNudge(sessionId) {
+    if (nudgePending.has(sessionId)) {
+      return false;
+    }
+    if (needsCompactionFollowUp.has(sessionId)) {
+      return false;
+    }
+    const createdAt = sessionCreatedAt.get(sessionId);
+    if (!createdAt || Date.now() - createdAt < 5 * 60 * 1000) {
+      return false;
+    }
+    const lastSave = lastMemSaveAt.get(sessionId);
+    if (lastSave && Date.now() - lastSave < 15 * 60 * 1000) {
+      return false;
+    }
+    nudgePending.add(sessionId);
+    return true;
+  }
   async function handleSessionCreated(session) {
     if (!enabled || !isRootSession(session)) {
       return;
     }
-    trackedRootSessions.add(session.id);
-    await thoth.memSessionStart(session.id);
+    const started = await thoth.memSessionStart(session.id);
+    if (started) {
+      trackedRootSessions.add(session.id);
+      sessionCreatedAt.set(session.id, Date.now());
+    } else {
+      log("[thoth] session start unavailable, skipping tracking:", session.id);
+    }
   }
   function handleSessionCompacted(session) {
     if (!enabled || !isRootSession(session) || !session.id) {
@@ -21394,6 +21504,9 @@ function createThothMemHook(options) {
     trackedRootSessions.delete(session.id);
     needsCompactionFollowUp.delete(session.id);
     ensuredRootSessions.delete(session.id);
+    sessionCreatedAt.delete(session.id);
+    lastMemSaveAt.delete(session.id);
+    nudgePending.delete(session.id);
   }
   return {
     event: async ({ event }) => {
@@ -21435,7 +21548,7 @@ function createThothMemHook(options) {
         return;
       }
       const sanitizedPromptText = sanitizePromptText(promptText);
-      if (!sanitizedPromptText) {
+      if (!sanitizedPromptText || sanitizedPromptText.length <= 10) {
         return;
       }
       await thoth.memSavePrompt(input.sessionID, sanitizedPromptText);
@@ -21450,8 +21563,15 @@ function createThothMemHook(options) {
       }
       const memoryInstructions = buildMemoryInstructions(input.sessionID, options.project);
       const compactionReminder = needsCompactionFollowUp.has(input.sessionID) ? buildCompactionReminder(input.sessionID) : null;
+      const saveNudge = shouldInjectSaveNudge(input.sessionID) ? buildSaveNudge() : null;
       if (output.system.length === 0) {
-        const systemPrompt = compactionReminder ? appendInstruction(memoryInstructions, compactionReminder) : memoryInstructions;
+        let systemPrompt = memoryInstructions;
+        if (compactionReminder) {
+          systemPrompt = appendInstruction(systemPrompt, compactionReminder);
+        }
+        if (saveNudge) {
+          systemPrompt = appendInstruction(systemPrompt, saveNudge);
+        }
         output.system.push(systemPrompt);
         return;
       }
@@ -21460,6 +21580,9 @@ function createThothMemHook(options) {
       if (compactionReminder) {
         updatedSystemPrompt = appendInstruction(updatedSystemPrompt, compactionReminder);
       }
+      if (saveNudge) {
+        updatedSystemPrompt = appendInstruction(updatedSystemPrompt, saveNudge);
+      }
       output.system[lastIndex] = updatedSystemPrompt;
     },
     "experimental.session.compacting": async (input, output) => {
@@ -21485,6 +21608,10 @@ function createThothMemHook(options) {
       if (!enabled) {
         return;
       }
+      if (isMemSaveTool(input.tool)) {
+        lastMemSaveAt.set(input.sessionID, Date.now());
+        nudgePending.delete(input.sessionID);
+      }
       if (isSessionSummaryTool(input.tool)) {
         needsCompactionFollowUp.delete(input.sessionID);
       }
@@ -21523,10 +21650,11 @@ function createThothMcp(config2) {
 }
 
 // src/mcp/websearch.ts
+var baseUrl = "https://mcp.exa.ai/mcp?tools=web_search_exa";
+var url2 = process.env.EXA_API_KEY ? `${baseUrl}&exaApiKey=${process.env.EXA_API_KEY}` : baseUrl;
 var websearch = {
   type: "remote",
-  url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
-  headers: process.env.EXA_API_KEY ? { "x-api-key": process.env.EXA_API_KEY } : undefined,
+  url: url2,
   oauth: false
 };
 
@@ -21554,7 +21682,7 @@ __export(exports_external2, {
   uuidv4: () => uuidv42,
   uuid: () => uuid5,
   util: () => exports_util2,
-  url: () => url2,
+  url: () => url3,
   uppercase: () => _uppercase2,
   unknown: () => unknown2,
   union: () => union2,
@@ -23868,10 +23996,10 @@ var $ZodURL2 = /* @__PURE__ */ $constructor2("$ZodURL", (inst, def) => {
   inst._zod.check = (payload) => {
     try {
       const trimmed = payload.value.trim();
-      const url2 = new URL(trimmed);
+      const url3 = new URL(trimmed);
       if (def.hostname) {
         def.hostname.lastIndex = 0;
-        if (!def.hostname.test(url2.hostname)) {
+        if (!def.hostname.test(url3.hostname)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -23885,7 +24013,7 @@ var $ZodURL2 = /* @__PURE__ */ $constructor2("$ZodURL", (inst, def) => {
       }
       if (def.protocol) {
         def.protocol.lastIndex = 0;
-        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
+        if (!def.protocol.test(url3.protocol.endsWith(":") ? url3.protocol.slice(0, -1) : url3.protocol)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -23898,7 +24026,7 @@ var $ZodURL2 = /* @__PURE__ */ $constructor2("$ZodURL", (inst, def) => {
         }
       }
       if (def.normalize) {
-        payload.value = url2.href;
+        payload.value = url3.href;
       } else {
         payload.value = trimmed;
       }
@@ -33000,7 +33128,7 @@ var ZodURL2 = /* @__PURE__ */ $constructor2("ZodURL", (inst, def) => {
   $ZodURL2.init(inst, def);
   ZodStringFormat2.init(inst, def);
 });
-function url2(params) {
+function url3(params) {
   return _url2(ZodURL2, params);
 }
 function httpUrl2(params) {
@@ -35994,8 +36122,15 @@ var lsp_rename = tool({
   }
 });
 // src/index.ts
+function resolveProjectName(project, directory) {
+  const runtimeProjectName = "name" in project && typeof project.name === "string" ? project.name : undefined;
+  return runtimeProjectName || path8.basename(directory) || "oh-my-opencode-lite";
+}
 var OhMyOpenCodeLite = async (ctx) => {
-  const config3 = loadPluginConfig(ctx.directory);
+  const { client, directory, project, worktree, $: shell, serverUrl } = ctx;
+  const worktreeDirectory = worktree || directory;
+  const projectName = resolveProjectName(project, directory);
+  const config3 = loadPluginConfig(directory);
   const agentDefs = createAgents(config3);
   const agents = getAgentConfigs(config3);
   const modelArrayMap = {};
@@ -36034,7 +36169,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   log("[plugin] initialized with tmux config", {
     tmuxConfig,
     rawTmuxConfig: config3.tmux,
-    directory: ctx.directory
+    directory
   });
   try {
     syncSkillsOnStartup();
@@ -36045,36 +36180,35 @@ var OhMyOpenCodeLite = async (ctx) => {
   if (tmuxConfig.enabled) {
     startTmuxCheck();
   }
-  const projectName = path8.basename(ctx.directory) || "oh-my-opencode-lite";
   let backgroundManager;
   const delegationManager = new DelegationManager({
-    directory: ctx.directory,
+    directory,
+    worktreeDirectory,
+    projectName,
+    shell,
     config: config3.delegation,
     getActiveTaskIds: (rootSessionId) => backgroundManager?.getActiveTaskIds(rootSessionId) ?? []
   });
-  backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig, config3, delegationManager);
+  backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig, config3, delegationManager, worktreeDirectory);
   const backgroundTools = createBackgroundTools(ctx, backgroundManager, tmuxConfig, config3);
   const mcps = createBuiltinMcps(config3.disabled_mcps, config3.thoth);
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
   const autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
     showStartupToast: true,
     autoUpdate: true
-  });
+  }, shell);
   const phaseReminderHook = createPhaseReminderHook();
-  const clarificationGateHook = createClarificationGateHook({
-    clarificationGate: config3.clarificationGate
-  });
   const postReadNudgeHook = createPostReadNudgeHook();
   const thothMemHook = createThothMemHook({
     project: projectName,
-    directory: ctx.directory,
+    directory,
     thoth: config3.thoth,
     enabled: true
   });
   const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
-  const foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config3.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
+  const foregroundFallback = new ForegroundFallbackManager(client, runtimeChains, config3.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
   return {
     name: "oh-my-opencode-lite",
     agent: agents,
@@ -36183,7 +36317,6 @@ var OhMyOpenCodeLite = async (ctx) => {
     },
     "experimental.chat.messages.transform": async (input, output) => {
       await phaseReminderHook["experimental.chat.messages.transform"](input, output);
-      await clarificationGateHook["experimental.chat.messages.transform"](input, output);
     },
     "experimental.session.compacting": async (input, output) => {
       if (thothMemHook["experimental.session.compacting"]) {