oh-my-opencode-serverlocal 0.1.7 → 0.1.9

package/dist/cli/index.js

@@ -552,6 +552,30 @@ 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: "tier0-workflow",
+    description: "Fast, direct implementation workflow for routine tasks. Basic state documentation, low cooperation overhead.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier0-workflow"
+  },
+  {
+    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,30 @@ 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: "tier0-workflow",
+    description: "Fast, direct implementation workflow for routine tasks. Basic state documentation, low cooperation overhead.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier0-workflow"
+  },
+  {
+    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"
   }
 ];
 
@@ -19022,7 +19046,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 +19063,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 +19077,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 +19121,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,62 +26296,54 @@ 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**
+  if (tier === 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.
+5. If visual design is needed, call @designer.`;
+  } else 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,
+    `Use the **tier${tier}-workflow** skill for this task. Load it to understand the required documentation structure.`,
+    `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` following the structure defined in your skill.",
+    "- Keep OpenCode todos synced.",
+    "",
     "Task:",
     task2
   ].join(`
@@ -26339,10 +26353,10 @@ function createTierCommandsHook() {
   const commands = ["tier0", "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, "tier0", "Start a Tier 0 session (Basic Mode)", "Tier 0");
+      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 +26368,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/dist/tui.js

@@ -471,6 +471,30 @@ 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: "tier0-workflow",
+    description: "Fast, direct implementation workflow for routine tasks. Basic state documentation, low cooperation overhead.",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/tier0-workflow"
+  },
+  {
+    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.7",
+  "version": "0.1.9",
   "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/tier0-workflow/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: tier0-workflow
+description: Fast, direct implementation workflow for routine tasks. Basic state documentation, low cooperation overhead.
+---
+
+# Tier 0 Workflow: Basic Mode
+
+Tier 0 is the default workflow for fast, direct implementation. Use it when the task is clear, routine, and does not require heavy supervision or ideation.
+
+## Core Contract
+- **State Management:** You must create and maintain a progress file at `.slim/tier_state/<short-task-slug>.md`.
+- **Git Ignore:** Before creating the state file, ensure `.gitignore` contains `.slim/tier_state/` and `.ignore` contains `!.slim/tier_state/` and `!.slim/tier_state/**`.
+- **Implementation:** You (Orchestrator) do the main implementation work. Use `@fixer` only for parallelizing simple, scoped file modifications across different folders.
+- **Review:** High threshold for asking for review. No mandatory `@oracle` review is required unless you encounter a critical roadblock.
+- **Research:** Use `@explorer` and `@librarian` freely for basic context gathering.
+- **Design:** If visual design is needed, call `@designer`. For vision extraction from images, call `@observer`.
+
+## Documentation Structure
+Your `.slim/tier_state/<short-task-slug>.md` file MUST follow this standard structure:
+
+### 1. Goal
+A concise statement of what needs to be implemented.
+
+### 2. Context
+Any researched facts, library documentation links from `@librarian`, or structural maps from `@explorer`. (Do not paste full file contents, use paths).
+
+### 3. Execution Plan
+A simple checklist of files to modify and steps to take. Keep OpenCode todos synced with this plan.
+
+### 4. Implementation Log
+Record task IDs of any spawned background sub-agents (e.g., `@fixer`). Record terminal results and completed steps.
+
+### 5. Final Validation
+A brief note confirming the code runs and meets the goal.

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.