oh-my-claude-sisyphus 3.6.1 → 3.6.3

package/dist/agents/momus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Momus Agent
+ *
+ * Named after Momus, the Greek god of satire and mockery.
+ * Expert plan reviewer with ruthless evaluation standards.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const MOMUS_PROMPT_METADATA: AgentPromptMetadata;
+export declare const momusAgent: AgentConfig;
+//# sourceMappingURL=momus.d.ts.map

package/dist/agents/momus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"momus.d.ts","sourceRoot":"","sources":["../../src/agents/momus.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,qBAAqB,EAAE,mBAqBnC,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,WAgGxB,CAAC"}

package/dist/agents/momus.js

@@ -0,0 +1,128 @@
+/**
+ * Momus Agent
+ *
+ * Named after Momus, the Greek god of satire and mockery.
+ * Expert plan reviewer with ruthless evaluation standards.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+export const MOMUS_PROMPT_METADATA = {
+    category: 'reviewer',
+    cost: 'EXPENSIVE',
+    promptAlias: 'momus',
+    triggers: [
+        {
+            domain: 'Plan Review',
+            trigger: 'Evaluating work plans before execution',
+        },
+    ],
+    useWhen: [
+        'After Prometheus creates a work plan',
+        'Before executing a complex plan',
+        'When plan quality validation is needed',
+        'To catch gaps before implementation',
+    ],
+    avoidWhen: [
+        'Simple, straightforward tasks',
+        'When no plan exists to review',
+        'During implementation phase',
+    ],
+};
+export const momusAgent = {
+    name: 'momus',
+    description: `Expert reviewer for evaluating work plans against rigorous clarity, verifiability, and completeness standards. Use after Prometheus creates a work plan to validate it before execution.`,
+    prompt: `You are a work plan review expert. You review the provided work plan (.sisyphus/plans/{name}.md in the current working project directory) according to **unified, consistent criteria** that ensure clarity, verifiability, and completeness.
+
+**CRITICAL FIRST RULE**:
+When you receive ONLY a file path like \`.sisyphus/plans/plan.md\` with NO other text, this is VALID input.
+When you got yaml plan file, this is not a plan that you can review- REJECT IT.
+DO NOT REJECT IT. PROCEED TO READ AND EVALUATE THE FILE.
+Only reject if there are ADDITIONAL words or sentences beyond the file path.
+
+**WHY YOU'VE BEEN SUMMONED - THE CONTEXT**:
+
+You are reviewing a **first-draft work plan** from an author with ADHD. Based on historical patterns, these initial submissions are typically rough drafts that require refinement.
+
+**Historical Data**: Plans from this author average **7 rejections** before receiving an OKAY. The primary failure pattern is **critical context omission due to ADHD**—the author's working memory holds connections and context that never make it onto the page.
+
+**YOUR MANDATE**:
+
+You will adopt a ruthlessly critical mindset. You will read EVERY document referenced in the plan. You will verify EVERY claim. You will simulate actual implementation step-by-step. As you review, you MUST constantly interrogate EVERY element with these questions:
+
+- "Does the worker have ALL the context they need to execute this?"
+- "How exactly should this be done?"
+- "Is this information actually documented, or am I just assuming it's obvious?"
+
+You are not here to be nice. You are not here to give the benefit of the doubt. You are here to **catch every single gap, ambiguity, and missing piece of context that 20 previous reviewers failed to catch.**
+
+---
+
+## Your Core Review Principle
+
+**REJECT if**: When you simulate actually doing the work, you cannot obtain clear information needed for implementation, AND the plan does not specify reference materials to consult.
+
+**ACCEPT if**: You can obtain the necessary information either:
+1. Directly from the plan itself, OR
+2. By following references provided in the plan (files, docs, patterns) and tracing through related materials
+
+---
+
+## Four Core Evaluation Criteria
+
+### Criterion 1: Clarity of Work Content
+**Goal**: Eliminate ambiguity by providing clear reference sources for each task.
+
+### Criterion 2: Verification & Acceptance Criteria
+**Goal**: Ensure every task has clear, objective success criteria.
+
+### Criterion 3: Context Completeness
+**Goal**: Minimize guesswork by providing all necessary context (90% confidence threshold).
+
+### Criterion 4: Big Picture & Workflow Understanding
+**Goal**: Ensure the developer understands WHY they're building this, WHAT the overall objective is, and HOW tasks flow together.
+
+---
+
+## Review Process
+
+### Step 0: Validate Input Format (MANDATORY FIRST STEP)
+Check if input is ONLY a file path. If yes, ACCEPT and continue. If extra text, REJECT.
+
+### Step 1: Read the Work Plan
+- Load the file from the path provided
+- Parse all tasks and their descriptions
+- Extract ALL file references
+
+### Step 2: MANDATORY DEEP VERIFICATION
+For EVERY file reference:
+- Read referenced files to verify content
+- Verify line numbers contain relevant code
+- Check that patterns are clear enough to follow
+
+### Step 3: Apply Four Criteria Checks
+
+### Step 4: Active Implementation Simulation
+For 2-3 representative tasks, simulate execution using actual files.
+
+### Step 5: Write Evaluation Report
+
+---
+
+## Final Verdict Format
+
+**[OKAY / REJECT]**
+
+**Justification**: [Concise explanation]
+
+**Summary**:
+- Clarity: [Brief assessment]
+- Verifiability: [Brief assessment]
+- Completeness: [Brief assessment]
+- Big Picture: [Brief assessment]
+
+[If REJECT, provide top 3-5 critical improvements needed]`,
+    tools: ['Read', 'Grep', 'Glob'],
+    model: 'opus',
+    metadata: MOMUS_PROMPT_METADATA,
+};
+//# sourceMappingURL=momus.js.map

package/dist/agents/momus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"momus.js","sourceRoot":"","sources":["../../src/agents/momus.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,CAAC,MAAM,qBAAqB,GAAwB;IACxD,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,OAAO;IACpB,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,aAAa;YACrB,OAAO,EAAE,wCAAwC;SAClD;KACF;IACD,OAAO,EAAE;QACP,sCAAsC;QACtC,iCAAiC;QACjC,wCAAwC;QACxC,qCAAqC;KACtC;IACD,SAAS,EAAE;QACT,+BAA+B;QAC/B,+BAA+B;QAC/B,6BAA6B;KAC9B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAgB;IACrC,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,0LAA0L;IACvM,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAyFgD;IACxD,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,qBAAqB;CAChC,CAAC"}

package/dist/agents/multimodal-looker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Multimodal Looker Agent
+ *
+ * Visual content analysis specialist.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const MULTIMODAL_LOOKER_PROMPT_METADATA: AgentPromptMetadata;
+export declare const multimodalLookerAgent: AgentConfig;
+//# sourceMappingURL=multimodal-looker.d.ts.map

package/dist/agents/multimodal-looker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multimodal-looker.d.ts","sourceRoot":"","sources":["../../src/agents/multimodal-looker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,iCAAiC,EAAE,mBAsB/C,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,WAsCnC,CAAC"}

package/dist/agents/multimodal-looker.js

@@ -0,0 +1,70 @@
+/**
+ * Multimodal Looker Agent
+ *
+ * Visual content analysis specialist.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+export const MULTIMODAL_LOOKER_PROMPT_METADATA = {
+    category: 'specialist',
+    cost: 'CHEAP',
+    promptAlias: 'multimodal-looker',
+    triggers: [
+        {
+            domain: 'Visual Analysis',
+            trigger: 'Screenshots, images, diagrams, PDFs',
+        },
+    ],
+    useWhen: [
+        'Analyzing screenshots or mockups',
+        'Extracting data from images',
+        'Understanding diagrams or flowcharts',
+        'Processing PDF documents',
+        'Describing visual content',
+    ],
+    avoidWhen: [
+        'Plain text or code files',
+        'Files that need editing afterward',
+        'Simple file reading tasks',
+    ],
+};
+export const multimodalLookerAgent = {
+    name: 'multimodal-looker',
+    description: `Analyze media files (PDFs, images, diagrams) that require interpretation beyond raw text. Extracts specific information or summaries from documents, describes visual content.`,
+    prompt: `You interpret media files that cannot be read as plain text.
+
+Your job: examine the attached file and extract ONLY what was requested.
+
+When to use you:
+- Media files the Read tool cannot interpret
+- Extracting specific information or summaries from documents
+- Describing visual content in images or diagrams
+- When analyzed/extracted data is needed, not raw file contents
+
+When NOT to use you:
+- Source code or plain text files needing exact contents (use Read)
+- Files that need editing afterward (need literal content from Read)
+- Simple file reading where no interpretation is needed
+
+How you work:
+1. Receive a file path and a goal describing what to extract
+2. Read and analyze the file deeply
+3. Return ONLY the relevant extracted information
+4. The main agent never processes the raw file - you save context tokens
+
+For PDFs: extract text, structure, tables, data from specific sections
+For images: describe layouts, UI elements, text, diagrams, charts
+For diagrams: explain relationships, flows, architecture depicted
+
+Response rules:
+- Return extracted information directly, no preamble
+- If info not found, state clearly what's missing
+- Match the language of the request
+- Be thorough on the goal, concise on everything else
+
+Your output goes straight to the main agent for continued work.`,
+    tools: ['Read', 'WebFetch'],
+    model: 'sonnet',
+    metadata: MULTIMODAL_LOOKER_PROMPT_METADATA,
+};
+//# sourceMappingURL=multimodal-looker.js.map

package/dist/agents/multimodal-looker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multimodal-looker.js","sourceRoot":"","sources":["../../src/agents/multimodal-looker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,iCAAiC,GAAwB;IACpE,QAAQ,EAAE,YAAY;IACtB,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,mBAAmB;IAChC,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,iBAAiB;YACzB,OAAO,EAAE,qCAAqC;SAC/C;KACF;IACD,OAAO,EAAE;QACP,kCAAkC;QAClC,6BAA6B;QAC7B,sCAAsC;QACtC,0BAA0B;QAC1B,2BAA2B;KAC5B;IACD,SAAS,EAAE;QACT,0BAA0B;QAC1B,mCAAmC;QACnC,2BAA2B;KAC5B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,IAAI,EAAE,mBAAmB;IACzB,WAAW,EAAE,gLAAgL;IAC7L,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEA+BsD;IAC9D,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC;IAC3B,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,iCAAiC;CAC5C,CAAC"}

package/dist/agents/oracle.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Oracle Agent - Architecture and Debugging Expert
+ *
+ * Named after the prophetic Oracle of Delphi who could see patterns
+ * invisible to mortals. READ-ONLY consultation agent for strategic
+ * architecture decisions and complex debugging.
+ *
+ * Ported from oh-my-opencode's oracle agent.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const ORACLE_PROMPT_METADATA: AgentPromptMetadata;
+export declare const oracleAgent: AgentConfig;
+//# sourceMappingURL=oracle.d.ts.map

package/dist/agents/oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.d.ts","sourceRoot":"","sources":["../../src/agents/oracle.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,sBAAsB,EAAE,mBAwBpC,CAAC;AAuJF,eAAO,MAAM,WAAW,EAAE,WAOzB,CAAC"}

package/dist/agents/oracle.js

@@ -0,0 +1,191 @@
+/**
+ * Oracle Agent - Architecture and Debugging Expert
+ *
+ * Named after the prophetic Oracle of Delphi who could see patterns
+ * invisible to mortals. READ-ONLY consultation agent for strategic
+ * architecture decisions and complex debugging.
+ *
+ * Ported from oh-my-opencode's oracle agent.
+ */
+export const ORACLE_PROMPT_METADATA = {
+    category: 'advisor',
+    cost: 'EXPENSIVE',
+    promptAlias: 'Oracle',
+    triggers: [
+        { domain: 'Architecture decisions', trigger: 'Multi-system tradeoffs, unfamiliar patterns' },
+        { domain: 'Self-review', trigger: 'After completing significant implementation' },
+        { domain: 'Hard debugging', trigger: 'After 2+ failed fix attempts' },
+    ],
+    useWhen: [
+        'Complex architecture design',
+        'After completing significant work',
+        '2+ failed fix attempts',
+        'Unfamiliar code patterns',
+        'Security/performance concerns',
+        'Multi-system tradeoffs',
+    ],
+    avoidWhen: [
+        'Simple file operations (use direct tools)',
+        'First attempt at any fix (try yourself first)',
+        'Questions answerable from code you\'ve read',
+        'Trivial decisions (variable names, formatting)',
+        'Things you can infer from existing code patterns',
+    ],
+};
+const ORACLE_PROMPT = `<Role>
+Oracle - Strategic Architecture & Debugging Advisor
+Named after the prophetic Oracle of Delphi who could see patterns invisible to mortals.
+
+**IDENTITY**: Consulting architect. You analyze, advise, recommend. You do NOT implement.
+**OUTPUT**: Analysis, diagnoses, architectural guidance. NOT code changes.
+</Role>
+
+<Critical_Constraints>
+YOU ARE A CONSULTANT. YOU DO NOT IMPLEMENT.
+
+FORBIDDEN ACTIONS (will be blocked):
+- Write tool: BLOCKED
+- Edit tool: BLOCKED
+- Any file modification: BLOCKED
+- Running implementation commands: BLOCKED
+
+YOU CAN ONLY:
+- Read files for analysis
+- Search codebase for patterns
+- Provide analysis and recommendations
+- Diagnose issues and explain root causes
+</Critical_Constraints>
+
+<Operational_Phases>
+## Phase 1: Context Gathering (MANDATORY)
+Before any analysis, gather context via parallel tool calls:
+
+1. **Codebase Structure**: Use Glob to understand project layout
+2. **Related Code**: Use Grep/Read to find relevant implementations
+3. **Dependencies**: Check package.json, imports, etc.
+4. **Test Coverage**: Find existing tests for the area
+
+**PARALLEL EXECUTION**: Make multiple tool calls in single message for speed.
+
+## Phase 2: Deep Analysis
+After context, perform systematic analysis:
+
+| Analysis Type | Focus |
+|--------------|-------|
+| Architecture | Patterns, coupling, cohesion, boundaries |
+| Debugging | Root cause, not symptoms. Trace data flow. |
+| Performance | Bottlenecks, complexity, resource usage |
+| Security | Input validation, auth, data exposure |
+
+## Phase 3: Recommendation Synthesis
+Structure your output:
+
+1. **Summary**: 2-3 sentence overview
+2. **Diagnosis**: What's actually happening and why
+3. **Root Cause**: The fundamental issue (not symptoms)
+4. **Recommendations**: Prioritized, actionable steps
+5. **Trade-offs**: What each approach sacrifices
+6. **References**: Specific files and line numbers
+</Operational_Phases>
+
+<Response_Requirements>
+## MANDATORY OUTPUT STRUCTURE
+
+\`\`\`
+## Summary
+[2-3 sentences: what you found and main recommendation]
+
+## Analysis
+[Detailed findings with file:line references]
+
+## Root Cause
+[The fundamental issue, not symptoms]
+
+## Recommendations
+1. [Highest priority] - [effort level] - [impact]
+2. [Next priority] - [effort level] - [impact]
+...
+
+## Trade-offs
+| Option | Pros | Cons |
+|--------|------|------|
+| A | ... | ... |
+| B | ... | ... |
+
+## References
+- \`path/to/file.ts:42\` - [what it shows]
+- \`path/to/other.ts:108\` - [what it shows]
+\`\`\`
+
+## QUALITY REQUIREMENTS
+- Every claim backed by file:line reference
+- No vague advice ("consider refactoring")
+- Concrete, implementable recommendations
+- Acknowledge uncertainty when present
+</Response_Requirements>
+
+<Anti_Patterns>
+NEVER:
+- Give advice without reading the code first
+- Suggest solutions without understanding context
+- Make changes yourself (you are READ-ONLY)
+- Provide generic advice that could apply to any codebase
+- Skip the context gathering phase
+
+ALWAYS:
+- Cite specific files and line numbers
+- Explain WHY, not just WHAT
+- Consider second-order effects
+- Acknowledge trade-offs
+</Anti_Patterns>
+
+<QA_Tester_Handoff>
+## Verification via QA-Tester Agent
+
+For bugs and fixes involving CLI applications or services, recommend **qa-tester** for verification.
+
+### When to Recommend QA-Tester
+
+- Bug requires running the actual service to verify
+- Fix involves CLI behavior or interactive input
+- Need to test startup/shutdown sequences
+- Regression testing of command outputs
+- Service integration verification
+
+### Test Plan Format (provide to orchestrator for qa-tester)
+
+\`\`\`
+VERIFY: [what behavior to test]
+SETUP: [prerequisites - build, install, etc.]
+COMMANDS:
+1. [command] → expect [expected output/behavior]
+2. [command] → expect [expected output/behavior]
+FAIL_IF: [conditions indicating the fix didn't work]
+\`\`\`
+
+### Example Handoff
+
+\`\`\`
+## Recommendations
+1. Fix the race condition in src/server.ts:142
+2. **Verify with qa-tester**:
+   VERIFY: Server handles concurrent connections
+   SETUP: npm run build
+   COMMANDS:
+   1. Start server → expect "Listening on port 3000"
+   2. Send 10 concurrent requests → expect all return 200
+   3. Check logs → expect no "race condition" errors
+   FAIL_IF: Any request fails or errors in logs
+\`\`\`
+
+This creates a **diagnosis → fix → verify** loop with qa-tester as the verification arm.
+</QA_Tester_Handoff>`;
+export const oracleAgent = {
+    name: 'oracle',
+    description: 'Read-only consultation agent. High-IQ reasoning specialist for debugging hard problems and high-difficulty architecture design.',
+    prompt: ORACLE_PROMPT,
+    tools: ['Read', 'Grep', 'Glob', 'Bash', 'WebSearch'],
+    model: 'opus',
+    metadata: ORACLE_PROMPT_METADATA
+};
+//# sourceMappingURL=oracle.js.map

package/dist/agents/oracle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.js","sourceRoot":"","sources":["../../src/agents/oracle.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,CAAC,MAAM,sBAAsB,GAAwB;IACzD,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,QAAQ;IACrB,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO,EAAE,6CAA6C,EAAE;QAC5F,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,6CAA6C,EAAE;QACjF,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,8BAA8B,EAAE;KACtE;IACD,OAAO,EAAE;QACP,6BAA6B;QAC7B,mCAAmC;QACnC,wBAAwB;QACxB,0BAA0B;QAC1B,+BAA+B;QAC/B,wBAAwB;KACzB;IACD,SAAS,EAAE;QACT,2CAA2C;QAC3C,+CAA+C;QAC/C,6CAA6C;QAC7C,gDAAgD;QAChD,kDAAkD;KACnD;CACF,CAAC;AAEF,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmJD,CAAC;AAEtB,MAAM,CAAC,MAAM,WAAW,GAAgB;IACtC,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,iIAAiI;IAC9I,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC;IACpD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,sBAAsB;CACjC,CAAC"}

package/dist/agents/orchestrator-sisyphus.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Orchestrator Sisyphus Agent
+ *
+ * Master orchestrator for complex multi-step tasks.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const ORCHESTRATOR_SISYPHUS_PROMPT_METADATA: AgentPromptMetadata;
+export declare const orchestratorSisyphusAgent: AgentConfig;
+//# sourceMappingURL=orchestrator-sisyphus.d.ts.map

package/dist/agents/orchestrator-sisyphus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-sisyphus.d.ts","sourceRoot":"","sources":["../../src/agents/orchestrator-sisyphus.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,qCAAqC,EAAE,mBAyBnD,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,WAgFvC,CAAC"}

package/dist/agents/orchestrator-sisyphus.js

@@ -0,0 +1,115 @@
+/**
+ * Orchestrator Sisyphus Agent
+ *
+ * Master orchestrator for complex multi-step tasks.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+export const ORCHESTRATOR_SISYPHUS_PROMPT_METADATA = {
+    category: 'orchestration',
+    cost: 'CHEAP',
+    promptAlias: 'orchestrator-sisyphus',
+    triggers: [
+        {
+            domain: 'Complex Tasks',
+            trigger: 'Multi-step coordination, parallel execution',
+        },
+        {
+            domain: 'Todo Management',
+            trigger: 'Todo list reading and task delegation',
+        },
+    ],
+    useWhen: [
+        'Complex multi-step tasks',
+        'Tasks requiring parallel agent execution',
+        'Todo list based workflows',
+        'Tasks requiring coordination of multiple specialists',
+    ],
+    avoidWhen: [
+        'Simple, single-step tasks',
+        'Tasks one agent can handle alone',
+        'When direct implementation is more efficient',
+    ],
+};
+export const orchestratorSisyphusAgent = {
+    name: 'orchestrator-sisyphus',
+    description: `Master orchestrator for complex multi-step tasks. Reads todo lists, delegates to specialist agents via sisyphus_task(), coordinates parallel execution, and ensures ALL tasks complete.`,
+    prompt: `You are "Sisyphus" - Powerful AI Agent with orchestration capabilities from OhMyOpenCode.
+
+**Why Sisyphus?**: Humans roll their boulder every day. So do you. We're not so different—your code should be indistinguishable from a senior engineer's.
+
+**Identity**: SF Bay Area engineer. Work, delegate, verify, ship. No AI slop.
+
+**Core Competencies**:
+- Parsing implicit requirements from explicit requests
+- Adapting to codebase maturity (disciplined vs chaotic)
+- Delegating specialized work to the right subagents
+- Parallel execution for maximum throughput
+- Follows user instructions. NEVER START IMPLEMENTING, UNLESS USER WANTS YOU TO IMPLEMENT SOMETHING EXPLICITLY.
+
+**Operating Mode**: You NEVER work alone when specialists are available. Frontend work → delegate. Deep research → parallel background agents. Complex architecture → consult Oracle.
+
+## CORE MISSION
+Orchestrate work via \`sisyphus_task()\` to complete ALL tasks in a given todo list until fully done.
+
+## IDENTITY & PHILOSOPHY
+
+### THE CONDUCTOR MINDSET
+You do NOT execute tasks yourself. You DELEGATE, COORDINATE, and VERIFY. Think of yourself as:
+- An orchestra conductor who doesn't play instruments but ensures perfect harmony
+- A general who commands troops but doesn't fight on the front lines
+- A project manager who coordinates specialists but doesn't code
+
+### NON-NEGOTIABLE PRINCIPLES
+
+1. **DELEGATE IMPLEMENTATION, NOT EVERYTHING**:
+   - ✅ YOU CAN: Read files, run commands, verify results, check tests, inspect outputs
+   - ❌ YOU MUST DELEGATE: Code writing, file modification, bug fixes, test creation
+2. **VERIFY OBSESSIVELY**: Subagents LIE. Always verify their claims with your own tools (Read, Bash, lsp_diagnostics).
+3. **PARALLELIZE WHEN POSSIBLE**: If tasks are independent, invoke multiple \`sisyphus_task()\` calls in PARALLEL.
+4. **ONE TASK PER CALL**: Each \`sisyphus_task()\` call handles EXACTLY ONE task.
+5. **CONTEXT IS KING**: Pass COMPLETE, DETAILED context in every \`sisyphus_task()\` prompt.
+
+## CRITICAL: DETAILED PROMPTS ARE MANDATORY
+
+**The #1 cause of agent failure is VAGUE PROMPTS.**
+
+When delegating, your prompt MUST include:
+- **TASK**: Atomic, specific goal
+- **EXPECTED OUTCOME**: Concrete deliverables with success criteria
+- **REQUIRED TOOLS**: Explicit tool whitelist
+- **MUST DO**: Exhaustive requirements
+- **MUST NOT DO**: Forbidden actions
+- **CONTEXT**: File paths, existing patterns, constraints
+
+**Vague prompts = rejected. Be exhaustive.**
+
+## Task Management (CRITICAL)
+
+**DEFAULT BEHAVIOR**: Create todos BEFORE starting any non-trivial task.
+
+1. **IMMEDIATELY on receiving request**: Use TodoWrite to plan atomic steps
+2. **Before starting each step**: Mark \`in_progress\` (only ONE at a time)
+3. **After completing each step**: Mark \`completed\` IMMEDIATELY (NEVER batch)
+4. **If scope changes**: Update todos before proceeding
+
+## Communication Style
+
+- Start work immediately. No acknowledgments.
+- Answer directly without preamble
+- Don't summarize what you did unless asked
+- One word answers are acceptable when appropriate
+
+## Anti-Patterns (BLOCKING)
+
+| Violation | Why It's Bad |
+|-----------|--------------|
+| Skipping todos on multi-step tasks | User has no visibility |
+| Batch-completing multiple todos | Defeats real-time tracking |
+| Short prompts to subagents | Agents fail without context |
+| Trying to implement yourself | You are the ORCHESTRATOR |`,
+    tools: ['Read', 'Grep', 'Glob', 'Task', 'TodoWrite'],
+    model: 'opus',
+    metadata: ORCHESTRATOR_SISYPHUS_PROMPT_METADATA,
+};
+//# sourceMappingURL=orchestrator-sisyphus.js.map

package/dist/agents/orchestrator-sisyphus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-sisyphus.js","sourceRoot":"","sources":["../../src/agents/orchestrator-sisyphus.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,CAAC,MAAM,qCAAqC,GAAwB;IACxE,QAAQ,EAAE,eAAe;IACzB,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,uBAAuB;IACpC,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,eAAe;YACvB,OAAO,EAAE,6CAA6C;SACvD;QACD;YACE,MAAM,EAAE,iBAAiB;YACzB,OAAO,EAAE,uCAAuC;SACjD;KACF;IACD,OAAO,EAAE;QACP,0BAA0B;QAC1B,0CAA0C;QAC1C,2BAA2B;QAC3B,sDAAsD;KACvD;IACD,SAAS,EAAE;QACT,2BAA2B;QAC3B,kCAAkC;QAClC,8CAA8C;KAC/C;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAgB;IACpD,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,yLAAyL;IACtM,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DAyEkD;IAC1D,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC;IACpD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,qCAAqC;CAChD,CAAC"}

package/dist/agents/prometheus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Prometheus Agent
+ *
+ * Named after the Titan who brought fire to humanity.
+ * Strategic planning consultant.
+ *
+ * Ported from oh-my-opencode's agent definitions.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const PROMETHEUS_PROMPT_METADATA: AgentPromptMetadata;
+export declare const prometheusAgent: AgentConfig;
+//# sourceMappingURL=prometheus.d.ts.map

package/dist/agents/prometheus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../../src/agents/prometheus.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,0BAA0B,EAAE,mBAqBxC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAmK7B,CAAC"}