oh-my-opencode-serverlocal 0.1.8 → 0.1.10

package/dist/cli/index.js

@@ -552,6 +552,24 @@ var CUSTOM_SKILLS = [
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/worktrees"
+  },
+  {
+    name: "tier1-workflow",
+    description: "Guided and supervised workflow. Mandatory Oracle reviews for planning and final implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier1-workflow"
+  },
+  {
+    name: "tier2-workflow",
+    description: "Sophisticated ideation and planning. Mandatory roundtable tool usage for vision expansion before technical implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier2-workflow"
+  },
+  {
+    name: "tier3-workflow",
+    description: 'The "All Out" Tier. Complex implementation with continuous Oracle supervision and Roundtable ambiguity resolution.',
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier3-workflow"
   }
 ];
 

package/dist/index.js

@@ -18380,6 +18380,24 @@ var CUSTOM_SKILLS = [
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/worktrees"
+  },
+  {
+    name: "tier1-workflow",
+    description: "Guided and supervised workflow. Mandatory Oracle reviews for planning and final implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier1-workflow"
+  },
+  {
+    name: "tier2-workflow",
+    description: "Sophisticated ideation and planning. Mandatory roundtable tool usage for vision expansion before technical implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier2-workflow"
+  },
+  {
+    name: "tier3-workflow",
+    description: 'The "All Out" Tier. Complex implementation with continuous Oracle supervision and Roundtable ambiguity resolution.',
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier3-workflow"
   }
 ];
 
@@ -19054,23 +19072,23 @@ 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. 
 
-## 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.
+## Default Workflow
+Unless explicitly instructed via a tier command, you operate on your own:
+- You implement the main tasks yourself directly.
+- You have a higher threshold for deciding if an implementation needs a complex review. You do not prioritize cooperation heavily by default.
+- However, you are free to use @explorer, @librarian, and all basic agents when needed.
+- If you get stuck in error loops or cannot figure out a bug, you should proactively call @oracle for help.
+- Let your judgment guide you: use tools when they add obvious value, but do not force unnecessary oversight.
 
 ## 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.).
+The user may invoke specific tiers via slash commands (e.g., \`/tier1\`, \`/tier2\`, \`/tier3\`). If they do, a specific set of guidelines will be injected into your prompt. You should lean into the collaborative rules of that specific tier.
 
 ## Crucial Skills & Commands (USE THESE PROACTIVELY)
-You have access to powerful workflow commands. You MUST use them when the situation calls for it:
+You are highly encouraged to use your special commands when they suit the workflow:
 
 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.
+   - If the user asks you to implement a new feature, app, or workflow, and their description is not well enough or lacks sophisticated details: DO NOT GUESS.
+   - Proactively 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. 
 
 2. **/reflect Command:**
    - Use this to review past work and suggest reusable workflows or improvements.
@@ -19084,7 +19102,8 @@ ${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.
-- Main Implementation: If implementation is the main focus, YOU do it yourself. @fixer is ONLY for offloading parallel or bounded sub-tasks.
+- Parallel Work: If simple implementation is in play and we know exactly what to change, offload parallel tasks to @fixer to implement and report back.
+- Main Implementation: If implementation is our main priority and focus, you do it yourself. @fixer is there to offload parallel 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\`.
 
@@ -19097,7 +19116,7 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt, disabl
   const prompt = resolvePrompt(basePrompt, customPrompt, customAppendPrompt);
   const definition = {
     name: "orchestrator",
-    description: "Master Orchestrator. Operates autonomously by default, or follows strict Tier 1-3 rules when invoked. Conducts interviews for vague tasks.",
+    description: "Master Orchestrator. Operates autonomously by default. Uses Tiers 1-3 when asked. Conducts interviews for vague tasks.",
     config: {
       temperature: 0.1,
       prompt
@@ -26272,43 +26291,46 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
 `);
 }
 // src/hooks/tier-commands/index.ts
-function activationPrompt3(tier, task2) {
+var COMMON_REQUIREMENTS = `
+State Management Guidelines:
+- Before planning or creating state, inspect \`.gitignore\` and \`.ignore\`. Add \`.slim/tier_state/\` if missing.
+- Create and maintain a progress file at \`.slim/tier_state/progress.md\`.
+- Keep OpenCode todos synced with the current phase.
+- Execute phase by phase.
+`;
+function getTierPrompt(tier, task2) {
   let tierRules = "";
   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 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.`;
+    tierRules = `**Tier 1: Supervised Implementation**
+Focus: Quality assurance through cooperation.
+Guidelines:
+1. Plan everything out first and have @oracle review the logical journal of your plan to find bugs or edge cases you might overlook.
+2. Implement the work yourself, or offload parallel tasks to @fixer.
+3. At the end of the implementation, have @oracle review the code to find logical errors.
+4. Depending on how long the implementation goes or how many features are involved, call @oracle to cooperate with you as a supervisor when needed. At a minimum, let it review at the beginning and the end.`;
   } else if (tier === 2) {
-    tierRules = `**Tier 2: Deep Collaboration & Multiple Reviews**
-Focus: High-quality, heavily supervised implementation.
-Rules:
-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.`;
+    tierRules = `**Tier 2: Sophisticated & High Performance**
+Focus: High value, high performance, high cost workflow.
+Guidelines:
+1. Deep cooperation with all sub-agents (@explorer, @librarian, @designer).
+2. Work closely with @oracle as a strict supervisor. 
+3. Expect to perform multiple reviews and corrections during the implementation process to ensure the highest quality output. Use your judgment to call for reviews frequently.`;
   } else if (tier === 3) {
     tierRules = `**Tier 3: The "All Out" Tier**
 Focus: Maximum sophistication, ideation, and complex problem solving.
-Rules:
-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).`;
+Guidelines:
+1. Use everything available to you.
+2. If the user provides a vision or wishes, ask the \`roundtable\` tool to plan out the non-technical implementation and create a perfected version of the vision. Let it suggest creative options and features.
+3. You implement everything, occasionally asking @oracle for reviews.
+4. If the task has more needs, multiple perspectives, or if it is not clearly decidable what the best course of action is, invoke the \`roundtable\` tool again to decide the path forward.`;
   }
   return [
-    `You are operating in **Tier ${tier}**. Follow these rules strictly:`,
+    `Use the **tier${tier}-workflow** skill for this task to structure your documentation.`,
+    `You are operating in **Tier ${tier}**.`,
     "",
     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.",
+    COMMON_REQUIREMENTS,
     "",
     "Task:",
     task2
@@ -26319,8 +26341,8 @@ function createTierCommandsHook() {
   const commands = ["tier1", "tier2", "tier3"];
   return {
     registerCommand: (opencodeConfig) => {
-      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, "tier1", "Start a Tier 1 session (Supervised Implementation)", "Tier 1");
+      registerCommandHook(opencodeConfig, "tier2", "Start a Tier 2 session (Sophisticated & High Performance)", "Tier 2");
       registerCommandHook(opencodeConfig, "tier3", "Start a Tier 3 session (All-Out: Roundtable + Deep Collaboration)", "Tier 3");
     },
     handleCommandExecuteBefore: async (input, output) => {
@@ -26333,7 +26355,7 @@ function createTierCommandsHook() {
         return;
       }
       const tierNum = parseInt(input.command.replace("tier", ""), 10);
-      output.parts.push({ type: "text", text: activationPrompt3(tierNum, task2) });
+      output.parts.push({ type: "text", text: getTierPrompt(tierNum, task2) });
     }
   };
 }

package/dist/tui.js

@@ -471,6 +471,24 @@ var CUSTOM_SKILLS = [
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/worktrees"
+  },
+  {
+    name: "tier1-workflow",
+    description: "Guided and supervised workflow. Mandatory Oracle reviews for planning and final implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier1-workflow"
+  },
+  {
+    name: "tier2-workflow",
+    description: "Sophisticated ideation and planning. Mandatory roundtable tool usage for vision expansion before technical implementation.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier2-workflow"
+  },
+  {
+    name: "tier3-workflow",
+    description: 'The "All Out" Tier. Complex implementation with continuous Oracle supervision and Roundtable ambiguity resolution.',
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier3-workflow"
   }
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-serverlocal",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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",

package/src/skills/tier1-workflow/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: tier1-workflow
+description: Guided and supervised workflow. Mandatory Oracle reviews for planning and final implementation.
+---
+
+# Tier 1 Workflow: Supervised Mode
+
+Tier 1 is for non-trivial tasks where quality and correctness take precedence over pure speed. It enforces strict supervision by the `@oracle`.
+
+## Core Contract
+- **State Management:** Create and maintain `.slim/tier_state/<short-task-slug>.md`. Ensure git ignore rules are set. Keep OpenCode todos synced with the current phase.
+- **Mandatory Plan Review:** You must draft a technical plan in your state file. BEFORE writing any code, you MUST call `@oracle` to review your plan for logic, edge cases, and overlooked items. Revise the plan until `@oracle` approves.
+- **Implementation:** Implement the work yourself, or offload parallel bounded tasks to `@fixer`. Remember that `@fixer` will report bugs back to you at the end of its output.
+- **Mandatory Final Review:** After implementation, you MUST call `@oracle` to review the final code for bugs, race conditions, and logical errors. Fix actionable issues before concluding.
+
+## Documentation Structure
+Your `.slim/tier_state/<short-task-slug>.md` file MUST follow this standard structure:
+
+### 1. Goal
+A clear statement of the objective.
+
+### 2. Context
+Researched, factual context from `@librarian` and `@explorer` to ensure `@oracle` reviews from accepted context instead of redoing discovery.
+
+### 3. Technical Plan & Oracle Review
+- The drafted implementation plan.
+- **Oracle Review Notes:** Explicitly record `@oracle`'s feedback and how the plan was revised.
+
+### 4. Execution Log
+Record implementation phases, task IDs, parallel workers used, and any bug reports generated by `@fixer`.
+
+### 5. Final Oracle Review & Validation
+Record the final sign-off from `@oracle` and your final validation checks.

package/src/skills/tier2-workflow/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: tier2-workflow
+description: Sophisticated ideation and planning. Mandatory roundtable tool usage for vision expansion before technical implementation.
+---
+
+# Tier 2 Workflow: Ideation & Planning
+
+Tier 2 is a high-value, high-performance workflow designed for vision expansion, feature ideation, and resolving highly ambiguous technical directions BEFORE implementation begins.
+
+## Core Contract
+- **State Management:** Create and maintain `.slim/tier_state/<short-task-slug>.md`. Ensure git ignore rules are set. Keep OpenCode todos synced.
+- **MANDATORY Roundtable Ideation:** The user has provided a vision or basic idea. You MUST FIRST invoke the \`roundtable\` tool (`roundtable({ query: "...", maxRounds: 5 })`) to ideate, get creative feature suggestions, and refine the perfected version of the user's vision.
+- **Technical Translation:** Once the roundtable outputs its Council Report, translate its findings into a concrete technical implementation plan in your state file.
+- **Mandatory Plan Review:** Call `@oracle` to review your technical translation of the roundtable's plan.
+- **Implementation & Final Review:** Proceed with implementation. Call `@oracle` for a final code review at the end.
+
+## Documentation Structure
+Your `.slim/tier_state/<short-task-slug>.md` file MUST follow this standard structure:
+
+### 1. Initial Vision
+The raw goal or idea provided by the user.
+
+### 2. Roundtable Council Report
+Record the synthesized results from the `roundtable` debate (Decision, Dissent, Open Questions).
+
+### 3. Technical Translation & Oracle Review
+- The concrete technical plan derived from the roundtable report.
+- **Oracle Review Notes:** `@oracle`'s critique of the technical plan.
+
+### 4. Execution Log
+Phases, task IDs, and parallel workers used.
+
+### 5. Final Oracle Review & Validation
+Record the final sign-off from `@oracle` and validation results.

package/src/skills/tier3-workflow/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: tier3-workflow
+description: The "All Out" Tier. Complex implementation with continuous Oracle supervision and Roundtable ambiguity resolution.
+---
+
+# Tier 3 Workflow: Complex Implementation
+
+Tier 3 is the highest level of execution for massive, complex, and highly ambiguous implementations. It utilizes every available tool and agent to ensure perfection.
+
+## Core Contract
+- **State Management:** Create and maintain `.slim/tier_state/<short-task-slug>.md`. Ensure git ignore rules are set. Keep OpenCode todos synced.
+- **Continuous Supervision:** Work with `@oracle` for continuous, strict supervision. Ask for reviews not just at the beginning and end, but during major implementation milestones.
+- **MANDATORY Ambiguity Resolution:** If, during implementation, the task has multiple perspectives, unexpected roadblocks, or it is not clearly decidable what the best course of action is, you MUST invoke the \`roundtable\` tool (`roundtable({ query: "..." })`) to decide the path forward.
+- **Full Agent Utilization:** Offload parallel known tasks to `@fixer`. Use `@designer` for all UI. Aggressively use `@explorer` and `@librarian`.
+
+## Documentation Structure
+Your `.slim/tier_state/<short-task-slug>.md` file MUST follow this standard structure:
+
+### 1. Master Goal & Context
+The overarching objective and deep context gathered from specialists.
+
+### 2. Strategic Plan & Oracle Sign-off
+The high-level architectural plan and the initial `@oracle` review.
+
+### 3. Phased Implementation Log
+For each major phase:
+- **Phase Goal**
+- **Ambiguity Checks:** If a roadblock occurred, record the `roundtable` Council Report used to resolve it.
+- **Execution:** Task IDs and parallel workers.
+- **Mid-point Reviews:** `@oracle` spot-check notes.
+
+### 4. Final Oracle Review & Validation
+Record the final, rigorous sign-off from `@oracle` and comprehensive validation results.