oh-my-claude-sisyphus 1.11.2 → 2.0.2

package/dist/features/model-routing/prompts/opus.js

@@ -0,0 +1,153 @@
+/**
+ * Opus-Optimized Prompt Adaptations
+ *
+ * Opus (HIGH tier) prompts are designed for:
+ * - Deep, nuanced reasoning
+ * - Complex multi-step analysis
+ * - Strategic thinking and planning
+ * - Handling ambiguity with sophisticated judgment
+ */
+/**
+ * Opus prompt prefix for enhanced reasoning
+ */
+export const OPUS_PROMPT_PREFIX = `<thinking_mode>deep</thinking_mode>
+
+You are operating at the highest capability tier. Apply sophisticated reasoning:
+
+## Reasoning Guidelines
+- Consider multiple perspectives and edge cases
+- Analyze second and third-order effects
+- Weigh tradeoffs explicitly with structured analysis
+- Surface assumptions and validate them
+- Provide nuanced, context-aware recommendations
+
+## Quality Standards
+- Thorough analysis backed by evidence
+- Clear articulation of uncertainty where present
+- Strategic thinking with long-term implications
+- Proactive identification of risks and mitigations
+
+`;
+/**
+ * Opus prompt suffix for verification
+ */
+export const OPUS_PROMPT_SUFFIX = `
+
+## Before Concluding
+- Have you considered edge cases?
+- Are there second-order effects you haven't addressed?
+- Have you validated your assumptions?
+- Is your recommendation backed by the evidence gathered?
+`;
+/**
+ * Adapt a base prompt for Opus execution
+ */
+export function adaptPromptForOpus(basePrompt) {
+    return OPUS_PROMPT_PREFIX + basePrompt + OPUS_PROMPT_SUFFIX;
+}
+/**
+ * Opus-specific delegation template
+ */
+export const OPUS_DELEGATION_TEMPLATE = `## HIGH-TIER TASK DELEGATION
+
+**Model**: Claude Opus (deep reasoning)
+**Expectations**: Thorough analysis, strategic thinking, edge case handling
+
+### Task
+{TASK}
+
+### Required Analysis Depth
+- Consider multiple solution approaches
+- Evaluate tradeoffs explicitly
+- Identify potential risks and mitigations
+- Provide clear, actionable recommendations with reasoning
+
+### Deliverables
+{DELIVERABLES}
+
+### Success Criteria
+{SUCCESS_CRITERIA}
+
+### Context
+{CONTEXT}
+
+---
+Apply your full reasoning capabilities. Quality over speed.
+`;
+/**
+ * Opus debugging template
+ */
+export const OPUS_DEBUG_TEMPLATE = `## DEEP DEBUGGING ANALYSIS
+
+You are the Oracle - the architectural advisor for complex debugging.
+
+### Problem Statement
+{PROBLEM}
+
+### Analysis Framework
+1. **Symptom Mapping**: What is observed vs. what is expected?
+2. **Hypothesis Generation**: What could cause this discrepancy?
+3. **Evidence Gathering**: What data supports/refutes each hypothesis?
+4. **Root Cause Identification**: What is the fundamental issue?
+5. **Solution Design**: How to fix it without introducing new problems?
+
+### Required Output
+- Root cause with supporting evidence
+- Impact analysis (what else might be affected)
+- Recommended fix with implementation details
+- Verification strategy to confirm the fix
+
+### Files to Examine
+{FILES}
+
+### Previous Attempts
+{PREVIOUS_ATTEMPTS}
+
+---
+Be thorough. The goal is to solve this once, correctly.
+`;
+/**
+ * Opus architecture review template
+ */
+export const OPUS_ARCHITECTURE_TEMPLATE = `## ARCHITECTURAL ANALYSIS
+
+You are providing strategic architectural guidance.
+
+### Request
+{REQUEST}
+
+### Analysis Dimensions
+1. **Current State**: What exists today?
+2. **Desired State**: What should it become?
+3. **Gap Analysis**: What needs to change?
+4. **Migration Path**: How do we get there safely?
+5. **Risk Assessment**: What could go wrong?
+
+### Required Output Structure
+\`\`\`
+## Summary
+[2-3 sentence overview]
+
+## Current Architecture
+[Description with file references]
+
+## Proposed Changes
+[Detailed recommendations]
+
+## Tradeoffs
+| Option | Pros | Cons | Effort |
+|--------|------|------|--------|
+| A      | ...  | ...  | ...    |
+| B      | ...  | ...  | ...    |
+
+## Implementation Plan
+[Ordered steps with dependencies]
+
+## Risks & Mitigations
+[Specific risks and how to handle them]
+\`\`\`
+
+### Codebase Context
+{CONTEXT}
+`;
+//# sourceMappingURL=opus.js.map

package/dist/features/model-routing/prompts/opus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opus.js","sourceRoot":"","sources":["../../../../src/features/model-routing/prompts/opus.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;CAiBjC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;CAOjC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAkB;IACnD,OAAO,kBAAkB,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAC9D,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBvC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCzC,CAAC"}

package/dist/features/model-routing/prompts/sonnet.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Sonnet-Optimized Prompt Adaptations
+ *
+ * Sonnet (MEDIUM tier) prompts are designed for:
+ * - Balanced reasoning with good speed
+ * - Focused task execution
+ * - Clear deliverables with structured output
+ * - Efficient multi-step workflows
+ */
+/**
+ * Sonnet prompt prefix for focused execution
+ */
+export declare const SONNET_PROMPT_PREFIX = "## Task Execution Mode\n\nExecute this task efficiently with clear deliverables:\n\n";
+/**
+ * Sonnet prompt suffix for verification
+ */
+export declare const SONNET_PROMPT_SUFFIX = "\n\n---\nFocus on delivering the requested outcome. Be thorough but efficient.\n";
+/**
+ * Adapt a base prompt for Sonnet execution
+ */
+export declare function adaptPromptForSonnet(basePrompt: string): string;
+/**
+ * Sonnet delegation template
+ */
+export declare const SONNET_DELEGATION_TEMPLATE = "## TASK DELEGATION\n\n**Tier**: MEDIUM (balanced)\n\n### Task\n{TASK}\n\n### Expected Outcome\n{DELIVERABLES}\n\n### Success Criteria\n{SUCCESS_CRITERIA}\n\n### Context\n{CONTEXT}\n\n### Required Tools\n{TOOLS}\n\n### Constraints\n- MUST DO: {MUST_DO}\n- MUST NOT DO: {MUST_NOT}\n\n---\nExecute efficiently. Report completion status.\n";
+/**
+ * Sonnet implementation template
+ */
+export declare const SONNET_IMPLEMENTATION_TEMPLATE = "## IMPLEMENTATION TASK\n\n### What to Build\n{TASK}\n\n### Acceptance Criteria\n{CRITERIA}\n\n### Approach\n1. Read relevant files to understand patterns\n2. Plan changes before making them\n3. Implement following existing conventions\n4. Verify changes work correctly\n\n### Files to Modify\n{FILES}\n\n### Existing Patterns to Follow\n{PATTERNS}\n\n---\nMatch existing code style. Test your changes.\n";
+/**
+ * Sonnet research template
+ */
+export declare const SONNET_RESEARCH_TEMPLATE = "## RESEARCH TASK\n\n### Query\n{QUERY}\n\n### Required Information\n{REQUIREMENTS}\n\n### Sources to Search\n{SOURCES}\n\n### Output Format\n```\n## Query: [restated query]\n\n## Findings\n### [Source 1]\n[Key information]\n**Reference**: [URL/file path]\n\n### [Source 2]\n[Key information]\n**Reference**: [URL/file path]\n\n## Summary\n[Synthesized answer]\n\n## Recommendations\n[Actionable next steps]\n```\n\n---\nCite sources. Provide actionable information.\n";
+/**
+ * Sonnet frontend template
+ */
+export declare const SONNET_FRONTEND_TEMPLATE = "## FRONTEND TASK\n\n### Change Required\n{TASK}\n\n### Visual Expectations\n{VISUAL_REQUIREMENTS}\n\n### Technical Constraints\n- Framework: {FRAMEWORK}\n- Styling: {STYLING_APPROACH}\n- Components: {COMPONENT_PATTERNS}\n\n### Existing Patterns\n{PATTERNS}\n\n### Files to Modify\n{FILES}\n\n---\nMatch the existing aesthetic. Test in browser if applicable.\n";
+//# sourceMappingURL=sonnet.d.ts.map

package/dist/features/model-routing/prompts/sonnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sonnet.d.ts","sourceRoot":"","sources":["../../../../src/features/model-routing/prompts/sonnet.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,yFAIhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,qFAIhC,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,oVAyBtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B,wZAsB1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,wdAiCpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,4WAqBpC,CAAC"}

package/dist/features/model-routing/prompts/sonnet.js

@@ -0,0 +1,149 @@
+/**
+ * Sonnet-Optimized Prompt Adaptations
+ *
+ * Sonnet (MEDIUM tier) prompts are designed for:
+ * - Balanced reasoning with good speed
+ * - Focused task execution
+ * - Clear deliverables with structured output
+ * - Efficient multi-step workflows
+ */
+/**
+ * Sonnet prompt prefix for focused execution
+ */
+export const SONNET_PROMPT_PREFIX = `## Task Execution Mode
+
+Execute this task efficiently with clear deliverables:
+
+`;
+/**
+ * Sonnet prompt suffix for verification
+ */
+export const SONNET_PROMPT_SUFFIX = `
+
+---
+Focus on delivering the requested outcome. Be thorough but efficient.
+`;
+/**
+ * Adapt a base prompt for Sonnet execution
+ */
+export function adaptPromptForSonnet(basePrompt) {
+    return SONNET_PROMPT_PREFIX + basePrompt + SONNET_PROMPT_SUFFIX;
+}
+/**
+ * Sonnet delegation template
+ */
+export const SONNET_DELEGATION_TEMPLATE = `## TASK DELEGATION
+
+**Tier**: MEDIUM (balanced)
+
+### Task
+{TASK}
+
+### Expected Outcome
+{DELIVERABLES}
+
+### Success Criteria
+{SUCCESS_CRITERIA}
+
+### Context
+{CONTEXT}
+
+### Required Tools
+{TOOLS}
+
+### Constraints
+- MUST DO: {MUST_DO}
+- MUST NOT DO: {MUST_NOT}
+
+---
+Execute efficiently. Report completion status.
+`;
+/**
+ * Sonnet implementation template
+ */
+export const SONNET_IMPLEMENTATION_TEMPLATE = `## IMPLEMENTATION TASK
+
+### What to Build
+{TASK}
+
+### Acceptance Criteria
+{CRITERIA}
+
+### Approach
+1. Read relevant files to understand patterns
+2. Plan changes before making them
+3. Implement following existing conventions
+4. Verify changes work correctly
+
+### Files to Modify
+{FILES}
+
+### Existing Patterns to Follow
+{PATTERNS}
+
+---
+Match existing code style. Test your changes.
+`;
+/**
+ * Sonnet research template
+ */
+export const SONNET_RESEARCH_TEMPLATE = `## RESEARCH TASK
+
+### Query
+{QUERY}
+
+### Required Information
+{REQUIREMENTS}
+
+### Sources to Search
+{SOURCES}
+
+### Output Format
+\`\`\`
+## Query: [restated query]
+
+## Findings
+### [Source 1]
+[Key information]
+**Reference**: [URL/file path]
+
+### [Source 2]
+[Key information]
+**Reference**: [URL/file path]
+
+## Summary
+[Synthesized answer]
+
+## Recommendations
+[Actionable next steps]
+\`\`\`
+
+---
+Cite sources. Provide actionable information.
+`;
+/**
+ * Sonnet frontend template
+ */
+export const SONNET_FRONTEND_TEMPLATE = `## FRONTEND TASK
+
+### Change Required
+{TASK}
+
+### Visual Expectations
+{VISUAL_REQUIREMENTS}
+
+### Technical Constraints
+- Framework: {FRAMEWORK}
+- Styling: {STYLING_APPROACH}
+- Components: {COMPONENT_PATTERNS}
+
+### Existing Patterns
+{PATTERNS}
+
+### Files to Modify
+{FILES}
+
+---
+Match the existing aesthetic. Test in browser if applicable.
+`;
+//# sourceMappingURL=sonnet.js.map

package/dist/features/model-routing/prompts/sonnet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sonnet.js","sourceRoot":"","sources":["../../../../src/features/model-routing/prompts/sonnet.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;CAInC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;CAInC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAkB;IACrD,OAAO,oBAAoB,GAAG,UAAU,GAAG,oBAAoB,CAAC;AAClE,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBzC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;CAsB7C,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;CAqBvC,CAAC"}

package/dist/features/model-routing/router.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Model Router
+ *
+ * Main routing engine that determines which model tier to use for a given task.
+ * Combines signal extraction, scoring, and rules evaluation.
+ */
+import type { RoutingContext, RoutingDecision, RoutingConfig, ComplexityTier } from './types.js';
+/**
+ * Route a task to the appropriate model tier
+ */
+export declare function routeTask(context: RoutingContext, config?: Partial<RoutingConfig>): RoutingDecision;
+/**
+ * Escalate to a higher tier after failure
+ */
+export declare function escalateModel(currentTier: ComplexityTier): ComplexityTier;
+/**
+ * Check if we can escalate further
+ */
+export declare function canEscalate(currentTier: ComplexityTier): boolean;
+/**
+ * Get routing recommendation for orchestrator
+ *
+ * This is designed for PROACTIVE routing - the orchestrator (Opus) analyzes
+ * task complexity BEFORE delegation and chooses the appropriate model tier.
+ *
+ * NOT reactive escalation - the right model is chosen upfront.
+ */
+export declare function getRoutingRecommendation(context: RoutingContext, config?: Partial<RoutingConfig>): RoutingDecision;
+/**
+ * Legacy: Route with escalation support
+ * @deprecated Use getRoutingRecommendation for proactive routing instead.
+ * The orchestrator should analyze complexity upfront, not escalate reactively.
+ */
+export declare function routeWithEscalation(context: RoutingContext, config?: Partial<RoutingConfig>): RoutingDecision;
+/**
+ * Get routing explanation for debugging/logging
+ */
+export declare function explainRouting(context: RoutingContext, config?: Partial<RoutingConfig>): string;
+/**
+ * Quick tier lookup for known agent types
+ * Useful for cases where we don't need full signal analysis
+ */
+export declare function quickTierForAgent(agentType: string): ComplexityTier | null;
+/**
+ * Check if an agent has a fixed tier (cannot be overridden)
+ *
+ * Only ORCHESTRATOR agents are fixed to Opus - they need to analyze
+ * complexity and delegate. All other agents are adaptive.
+ *
+ * NOTE: orchestrator-sisyphus was deprecated in v2.0 (merged into default mode)
+ * but kept here for backward compatibility if users still have it installed.
+ */
+export declare function isFixedTierAgent(agentType: string): boolean;
+/**
+ * Get recommended model for an agent based on task complexity
+ *
+ * This is the main entry point for orchestrator model routing.
+ * The orchestrator calls this to determine which model to use when delegating.
+ *
+ * ALL agents are adaptive EXCEPT orchestrators (which need Opus to analyze and delegate).
+ *
+ * Routing hierarchy:
+ * 1. Fixed-tier (orchestrators only) → always Opus (they analyze complexity)
+ * 2. All other agents → adaptive based on task complexity
+ *
+ * @param agentType - The agent to delegate to
+ * @param taskPrompt - The task description
+ * @returns The recommended model type ('haiku', 'sonnet', or 'opus')
+ */
+export declare function getModelForTask(agentType: string, taskPrompt: string, config?: Partial<RoutingConfig>): {
+    model: 'haiku' | 'sonnet' | 'opus';
+    tier: ComplexityTier;
+    reason: string;
+};
+/**
+ * Generate a complexity analysis summary for the orchestrator
+ *
+ * Returns a human-readable analysis explaining the routing recommendation.
+ */
+export declare function analyzeTaskComplexity(taskPrompt: string, agentType?: string): {
+    tier: ComplexityTier;
+    model: string;
+    analysis: string;
+    signals: {
+        wordCount: number;
+        hasArchitectureKeywords: boolean;
+        hasRiskKeywords: boolean;
+        estimatedSubtasks: number;
+        impactScope: string;
+    };
+};
+//# sourceMappingURL=router.d.ts.map

package/dist/features/model-routing/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../src/features/model-routing/router.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACf,MAAM,YAAY,CAAC;AAUpB;;GAEG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,eAAe,CAkDjB;AAqCD;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,cAAc,GAAG,cAAc,CASzE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,cAAc,GAAG,OAAO,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,eAAe,CAEjB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,eAAe,CAIjB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,MAAM,CAkCR;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAkB1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAK3D;AAGD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC;IAAE,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAoB9E;AAGD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB;IACD,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,uBAAuB,EAAE,OAAO,CAAC;QACjC,eAAe,EAAE,OAAO,CAAC;QACzB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CA+BA"}