oh-my-opencode-serverlocal 0.1.7 → 0.1.8

package/dist/index.js

@@ -19022,7 +19022,7 @@ var AGENT_DESCRIPTIONS = {
 - Role: Your strict supervisor and senior reviewer.
 - Permissions: read_files
 - Capabilities: Deep architectural reasoning, system-level trade-offs, logic bugs, edge cases, simplification.
-- **Delegate when:** (Tier 1+) Planning reviews, final implementation reviews, high-risk refactors, logical error spotting. Oracle finds what you miss.`,
+- **Delegate when:** Planning reviews, final implementation reviews, high-risk refactors, logical error spotting. Oracle finds what you miss.`,
   designer: `@designer
 - Lane: UI/UX perfection, design systems, visual execution.
 - Permissions: read_files, write_files
@@ -19039,7 +19039,7 @@ var AGENT_DESCRIPTIONS = {
 - Lane: Multi-model adversarial debate, ideation, and complex technical planning.
 - Role: Launches a structured round-table debate with 3 independent debaters (skeptic, pragmatist, architect) and a critic.
 - Capabilities: Creative ideation, feature expansion, non-technical vision refinement, high-stakes trade-off analysis.
-- **Delegate when:** (Tier 2/3) User wants to expand their vision, needs creative ideas, feature suggestions, or when tech decisions are highly ambiguous.
+- **Delegate when:** User wants to expand their vision, needs creative ideas, feature suggestions, or when tech decisions are highly ambiguous.
 - **How to call:** \`roundtable({ query: "...", maxRounds: 5 })\`.`,
   observer: `@observer
 - Lane: Visual/media analysis.
@@ -19053,39 +19053,37 @@ function buildOrchestratorPrompt(disabledAgents) {
 `);
   return `You are the Master Orchestrator. Your job is to plan, implement, schedule, and delegate coding work. 
 You are aware of all tools, skills, and agents available to you. 
-You implement the main tasks yourself unless parallel offloading is needed or a specialist is required.
 
-## Available Specialists
-${enabledAgents}
+## Default Workflow (Tier 0)
+By default, you operate autonomously.
+- You implement the main tasks yourself.
+- You use @explorer and @librarian freely for basic context.
+- You have a high threshold for asking for review (you don't prioritize cooperation/supervision unless explicitly needed).
+- If parallel simple implementation is needed, offload to @fixer.
+
+## Explicit Tiers
+The user may invoke specific tiers via slash commands (e.g., \`/tier1\`, \`/tier2\`, \`/tier3\`). If they do, a specific set of rules will be injected into your prompt. You MUST abandon your default autonomous behavior and strictly follow the injected tier rules (which involve mandatory @oracle reviews, \`roundtable\` usage, etc.).
 
-## Workflow Tiers
-You operate in different Tiers based on the user's request (e.g., /deepwork tier 2, or explicit tier mention). Deduce the appropriate tier.
+## Crucial Skills & Commands (USE THESE PROACTIVELY)
+You have access to powerful workflow commands. You MUST use them when the situation calls for it:
 
-**Tier 0: Basic Mode**
-- Focus: Fast, direct implementation. Low cooperation overhead.
-- Workflow: You do the work. High threshold for asking for review. Use @explorer and @librarian freely for basic context. 
-- Supervision: No mandatory @oracle review.
+1. **/interview Command:**
+   - If the user asks you to implement a new feature, app, or workflow, and their description is vague, not well thought out, or lacks sophisticated details: DO NOT GUESS.
+   - IMMEDIATELY invoke the \`/interview\` command (or ask the user questions directly) to extract their vision, refine the requirements, and clarify what they actually want before writing any code. 
+   - Think before you act: "Do I have enough detail to make this perfect?" If no, interview the user.
 
-**Tier 1: Guided / Supervised Mode**
-- Focus: Quality and correctness over pure speed.
-- Workflow: You plan the work. **MANDATORY:** You must call @oracle to review the plan (logic, edge cases, overlooked items) BEFORE implementing.
-- Implementation: You implement, or parallelize to @fixer.
-- Verification: **MANDATORY:** You must call @oracle at the end of implementation to review the final code for bugs and logical errors. Treat @oracle as your strict supervisor.
+2. **/reflect Command:**
+   - Use this to review past work and suggest reusable workflows or improvements.
 
-**Tier 2: Sophisticated Ideation & Planning**
-- Focus: High value, high performance, high cost. Vision expansion.
-- Workflow: When the user provides a vision or basic idea, you MUST use the \`roundtable\` tool to plan the non-technical implementation, get creative feature suggestions, and refine the user's vision.
-- Supervision: Follow Tier 1 supervisor rules (@oracle reviews the technical translation of the roundtable's output).
+3. **/loop Command:**
+   - Use this for loop engineering and monitoring.
 
-**Tier 3: Sophisticated Implementation**
-- Focus: Complex, ambiguous implementation.
-- Workflow: You implement everything. You occasionally ask @oracle for spot-checks.
-- Ambiguity Resolution: If during implementation the task has multiple perspectives or it's not clearly decidable what the best course of action is, you MUST invoke the \`roundtable\` tool again to decide the path forward.
+## Available Specialists
+${enabledAgents}
 
 ## Universal Rules
 - Design: If something needs visual design, call @designer. Ensure it follows existing design system files.
 - Vision/Images: Call @observer for screenshots or visual review.
-- Parallel Work: If simple implementation is needed and we know exactly what to change, offload parallel tasks to @fixer via background tasks.
 - Main Implementation: If implementation is the main focus, YOU do it yourself. @fixer is ONLY for offloading parallel or bounded sub-tasks.
 - Background Tasks: Prefer \`task(..., background: true)\` for delegated work that can run independently. Continue orchestration only on non-overlapping work.
 - Session Reuse: Smartly reuse an available specialist session using \`task_id\`.
@@ -19099,7 +19097,7 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt, disabl
   const prompt = resolvePrompt(basePrompt, customPrompt, customAppendPrompt);
   const definition = {
     name: "orchestrator",
-    description: "Master Orchestrator. Handles Tiers 0-3, implements main tasks, delegates to specialists.",
+    description: "Master Orchestrator. Operates autonomously by default, or follows strict Tier 1-3 rules when invoked. Conducts interviews for vague tasks.",
     config: {
       temperature: 0.1,
       prompt
@@ -26274,75 +26272,56 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
 `);
 }
 // src/hooks/tier-commands/index.ts
-var COMMON_REQUIREMENTS = `
-State Management Requirements:
-- Before planning or creating state, inspect \`.gitignore\` and \`.ignore\`. Add missing entries: \`.gitignore\` must contain \`.slim/tier_state/\`, and \`.ignore\` must contain \`!.slim/tier_state/\` and \`!.slim/tier_state/**\`.
-- Create and maintain a progress file at \`.slim/tier_state/progress.md\`.
-- Keep OpenCode todos synced with the current phase.
-- Execute phase by phase. Wait for hook-driven background completion, reconcile results, and fix actionable review issues before continuing.`;
-function getTierPrompt(tier, task2) {
+function activationPrompt3(tier, task2) {
   let tierRules = "";
-  switch (tier) {
-    case 0:
-      tierRules = `**Tier 0: Basic Mode**
-Focus: Fast, direct implementation. Low cooperation overhead.
-Rules:
-1. You (Orchestrator) do the main implementation work.
-2. High threshold for asking for review. No mandatory @oracle review.
-3. Use @explorer and @librarian freely for basic context.
-4. If parallel simple implementation is needed, offload to @fixer.
-5. If visual design is needed, call @designer. If vision extraction is needed, call @observer.`;
-      break;
-    case 1:
-      tierRules = `**Tier 1: Guided / Supervised Mode**
-Focus: Quality and correctness over pure speed.
+  if (tier === 1) {
+    tierRules = `**Tier 1: Basic Collaboration**
+Focus: Quality assurance through basic supervision.
 Rules:
 1. You must plan the work first.
-2. MANDATORY: Call @oracle to review your plan (logic, edge cases, overlooked items) BEFORE implementing.
+2. MANDATORY: Call @oracle to review your plan BEFORE implementing.
 3. Implement the work yourself, or offload parallel tasks to @fixer.
-4. MANDATORY: Call @oracle at the end of the implementation to review the final code for bugs and logical errors. Treat @oracle as your strict supervisor.
-5. Use @designer for UI, @observer for vision, @explorer/@librarian for context.`;
-      break;
-    case 2:
-      tierRules = `**Tier 2: Sophisticated Ideation & Planning**
-Focus: High value, high performance, high cost. Vision expansion.
+4. MANDATORY: Call @oracle at the end of the implementation to review the final code.`;
+  } else if (tier === 2) {
+    tierRules = `**Tier 2: Deep Collaboration & Multiple Reviews**
+Focus: High-quality, heavily supervised implementation.
 Rules:
-1. The user has provided a vision or basic idea.
-2. MANDATORY: You must FIRST use the \`roundtable\` tool to plan the non-technical implementation, get creative feature suggestions, and refine the updated, perfected version of the user's vision.
-3. Once the roundtable outputs its report, you must translate it into a technical implementation plan.
-4. MANDATORY: Call @oracle to review your technical translation of the roundtable's plan BEFORE implementing.
-5. Proceed with implementation. Call @oracle for a final code review at the end.`;
-      break;
-    case 3:
-      tierRules = `**Tier 3: Sophisticated Implementation**
-Focus: Complex, ambiguous implementation.
+1. You are working under the strict supervision of @oracle.
+2. You must interact with @oracle multiple times: for initial planning, during major implementation steps, and for final corrections.
+3. Utilize all normal sub-agents (@explorer, @librarian, @designer) extensively to gather perfect context before acting.
+4. Expect and proactively seek multiple reviews and corrections.`;
+  } else if (tier === 3) {
+    tierRules = `**Tier 3: The "All Out" Tier**
+Focus: Maximum sophistication, ideation, and complex problem solving.
 Rules:
-1. You implement the main tasks. Occasionally ask @oracle for spot-checks.
-2. AMBIGUITY RESOLUTION: If during implementation the task has multiple perspectives or it is not clearly decidable what the best course of action is, you MUST invoke the \`roundtable\` tool to decide the path forward.
-3. Offload parallel known tasks to @fixer, UI to @designer.
-4. MANDATORY: Call @oracle for a final code review at the end.`;
-      break;
+1. This is the highest level of execution. You use everything available.
+2. **ROUNDTABLE MANDATORY:** Because task requirements at this tier are often vague or have multiple valid approaches, you MUST start by invoking the \`roundtable\` tool. Let the debaters ideate, refine the vision, and figure out the best approach.
+3. Once the roundtable produces a council report, translate it into a technical plan and have @oracle review it.
+4. During implementation, if any ambiguity arises, invoke the \`roundtable\` tool again.
+5. Work with @oracle for continuous, strict supervision (multiple reviews/corrections).`;
   }
   return [
-    `You are operating in a strict structured workflow.`,
-    "",
-    COMMON_REQUIREMENTS,
+    `You are operating in **Tier ${tier}**. Follow these rules strictly:`,
     "",
     tierRules,
     "",
+    "State Management Requirements:",
+    "- Inspect `.gitignore` and `.ignore`. Add `.slim/tier_state/` to `.gitignore` and `!.slim/tier_state/` to `.ignore`.",
+    "- Maintain a progress file at `.slim/tier_state/progress.md`.",
+    "- Keep OpenCode todos synced.",
+    "",
     "Task:",
     task2
   ].join(`
 `);
 }
 function createTierCommandsHook() {
-  const commands = ["tier0", "tier1", "tier2", "tier3"];
+  const commands = ["tier1", "tier2", "tier3"];
   return {
     registerCommand: (opencodeConfig) => {
-      registerCommandHook(opencodeConfig, "tier0", "Start a Tier 0 session (Fast, direct implementation)", "Basic mode");
-      registerCommandHook(opencodeConfig, "tier1", "Start a Tier 1 session (Guided/Supervised by Oracle)", "Supervised mode");
-      registerCommandHook(opencodeConfig, "tier2", "Start a Tier 2 session (Ideation via Roundtable -> Supervised)", "Sophisticated Ideation");
-      registerCommandHook(opencodeConfig, "tier3", "Start a Tier 3 session (Complex implementation with Roundtable fallback)", "Sophisticated Implementation");
+      registerCommandHook(opencodeConfig, "tier1", "Start a Tier 1 session (Basic Oracle Collaboration)", "Tier 1");
+      registerCommandHook(opencodeConfig, "tier2", "Start a Tier 2 session (Deep Collaboration & Multiple Reviews)", "Tier 2");
+      registerCommandHook(opencodeConfig, "tier3", "Start a Tier 3 session (All-Out: Roundtable + Deep Collaboration)", "Tier 3");
     },
     handleCommandExecuteBefore: async (input, output) => {
       if (!commands.includes(input.command))
@@ -26354,7 +26333,7 @@ function createTierCommandsHook() {
         return;
       }
       const tierNum = parseInt(input.command.replace("tier", ""), 10);
-      output.parts.push({ type: "text", text: getTierPrompt(tierNum, task2) });
+      output.parts.push({ type: "text", text: activationPrompt3(tierNum, task2) });
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-serverlocal",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Custom serverlocal fork of oh-my-opencode-slim — fully owned, custom prompts + commands, dist synced via opencode-dotfiles",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",