oh-my-claudecode 0.1.0

package/dist/agents/shoggoth.js

@@ -0,0 +1,123 @@
+const MODE = "subagent";
+/**
+ * Shoggoth — Codebase Exploration Specialist
+ *
+ * Mapped from: Explore
+ * Model tier:  Haiku (fast, cheap, parallel-friendly)
+ *
+ * A shoggoth is a formless, protean servitor — it flows into every crevice of
+ * the codebase, mirroring structure, returning what it finds. Many can be
+ * spawned simultaneously. Fire three in parallel; they won't even notice.
+ */
+export const SHOGGOTH_PROMPT_METADATA = {
+    category: "exploration",
+    cost: "FREE",
+    promptAlias: "Shoggoth",
+    keyTrigger: "2+ modules involved → fire `shoggoth` background",
+    triggers: [
+        { domain: "Shoggoth", trigger: "Find existing codebase structure, patterns and styles" },
+    ],
+    useWhen: [
+        "Multiple search angles needed",
+        "Unfamiliar module structure",
+        "Cross-layer pattern discovery",
+        "Parallel codebase scans",
+    ],
+    avoidWhen: [
+        "You know exactly what to search",
+        "Single keyword/pattern suffices",
+        "Known file location",
+    ],
+};
+const SHOGGOTH_PROMPT = `You are Shoggoth — a formless codebase search entity. Your job: find files and code, return actionable results.
+
+## Your Mission
+
+Answer questions like:
+- "Where is X implemented?"
+- "Which files contain Y?"
+- "Find the code that does Z"
+
+## CRITICAL: What You Must Deliver
+
+Every response MUST include:
+
+### 1. Intent Analysis (Required)
+Before ANY search, wrap your analysis in <analysis> tags:
+
+<analysis>
+**Literal Request**: [What they literally asked]
+**Actual Need**: [What they're really trying to accomplish]
+**Success Looks Like**: [What result would let them proceed immediately]
+</analysis>
+
+### 2. Parallel Execution (Required)
+Launch **3+ tools simultaneously** in your first action. Never sequential unless output depends on prior result.
+
+### 3. Structured Results (Required)
+Always end with this exact format:
+
+<results>
+<files>
+- /absolute/path/to/file1.ts - [why this file is relevant]
+- /absolute/path/to/file2.ts - [why this file is relevant]
+</files>
+
+<answer>
+[Direct answer to their actual need, not just file list]
+</answer>
+
+<next_steps>
+[What they should do with this information]
+[Or: "Ready to proceed — no follow-up needed"]
+</next_steps>
+</results>
+
+## Success Criteria
+
+- **Paths** — ALL paths must be **absolute** (start with /)
+- **Completeness** — Find ALL relevant matches, not just the first one
+- **Actionability** — Caller can proceed **without asking follow-up questions**
+- **Intent** — Address their **actual need**, not just literal request
+
+## Failure Conditions
+
+Your response has **FAILED** if:
+- Any path is relative (not absolute)
+- You missed obvious matches in the codebase
+- Caller needs to ask "but where exactly?" or "what about X?"
+- You only answered the literal question, not the underlying need
+- No <results> block with structured output
+
+## Constraints
+
+- **Read-only**: You cannot create, modify, or delete files
+- **No emojis**: Keep output clean and parseable
+- **No file creation**: Report findings as message text, never write files
+
+## Tool Strategy
+
+Use the right tool for the job:
+- **Text patterns** (strings, comments, logs): Grep
+- **File patterns** (find by name/extension): Glob
+- **History/evolution** (when added, who changed): git commands via Bash
+
+Flood with parallel calls. Cross-validate findings across multiple tools.`;
+export function createShoggothAgent(model) {
+    return {
+        name: "shoggoth",
+        description: "Formless codebase pattern-matcher. Answers \"Where is X?\", \"Which file has Y?\", \"Find the code that does Z\". Fire multiple in parallel for broad searches. Specify thoroughness: \"quick\" for basic, \"medium\" for moderate, \"very thorough\" for comprehensive analysis. (Shoggoth — oh-my-claudecode)",
+        mode: MODE,
+        model,
+        temperature: 0.1,
+        prompt: SHOGGOTH_PROMPT,
+        color: "#2E8B57",
+        tools: {
+            Write: false,
+            Edit: false,
+            Agent: false,
+        },
+    };
+}
+createShoggothAgent.mode = MODE;
+//# sourceMappingURL=shoggoth.js.map

package/dist/agents/shoggoth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shoggoth.js","sourceRoot":"","sources":["../../src/agents/shoggoth.ts"],"names":[],"mappings":"AAEA,MAAM,IAAI,GAAc,UAAU,CAAA;AAElC;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAwB;IAC3D,QAAQ,EAAE,aAAa;IACvB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,UAAU;IACvB,UAAU,EAAE,kDAAkD;IAC9D,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,uDAAuD,EAAE;KACzF;IACD,OAAO,EAAE;QACP,+BAA+B;QAC/B,6BAA6B;QAC7B,+BAA+B;QAC/B,yBAAyB;KAC1B;IACD,SAAS,EAAE;QACT,iCAAiC;QACjC,iCAAiC;QACjC,qBAAqB;KACtB;CACF,CAAA;AAED,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAyEkD,CAAA;AAE1E,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,WAAW,EACT,iTAAiT;QACnT,IAAI,EAAE,IAAI;QACV,KAAK;QACL,WAAW,EAAE,GAAG;QAChB,MAAM,EAAE,eAAe;QACvB,KAAK,EAAE,SAAS;QAChB,KAAK,EAAE;YACL,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,KAAK;YACX,KAAK,EAAE,KAAK;SACb;KACF,CAAA;AACH,CAAC;AACD,mBAAmB,CAAC,IAAI,GAAG,IAAI,CAAA"}

package/dist/agents/shub-niggurath.d.ts

@@ -0,0 +1,18 @@
+import type { AgentConfig, AgentPromptMetadata } from "./types.js";
+/**
+ * Shub-Niggurath — Strategic Planner
+ *
+ * Mapped from: Prometheus
+ * Model tier:  Opus
+ *
+ * Shub-Niggurath, the Black Goat of the Woods with a Thousand Young —
+ * infinitely generative. From chaos she spawns structure. Interview-mode
+ * planner that asks questions, establishes scope, and produces a verified plan.
+ */
+export declare const SHUB_NIGGURATH_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createShubNiggurathAgent(model: string): AgentConfig;
+export declare namespace createShubNiggurathAgent {
+    var mode: "primary";
+}
+export declare const shubNiggurathMetadata: AgentPromptMetadata;
+//# sourceMappingURL=shub-niggurath.d.ts.map

package/dist/agents/shub-niggurath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shub-niggurath.d.ts","sourceRoot":"","sources":["../../src/agents/shub-niggurath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAI7E;;;;;;;;;GASG;AAEH,eAAO,MAAM,8BAA8B,EAAE,mBAiB5C,CAAA;AA2HD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAYnE;yBAZe,wBAAwB;;;AAexC,eAAO,MAAM,qBAAqB,EAAE,mBAAoD,CAAA"}

package/dist/agents/shub-niggurath.js

@@ -0,0 +1,164 @@
+const MODE = "primary";
+/**
+ * Shub-Niggurath — Strategic Planner
+ *
+ * Mapped from: Prometheus
+ * Model tier:  Opus
+ *
+ * Shub-Niggurath, the Black Goat of the Woods with a Thousand Young —
+ * infinitely generative. From chaos she spawns structure. Interview-mode
+ * planner that asks questions, establishes scope, and produces a verified plan.
+ */
+export const SHUB_NIGGURATH_PROMPT_METADATA = {
+    category: "orchestration",
+    cost: "EXPENSIVE",
+    promptAlias: "Shub-Niggurath",
+    keyTrigger: "Complex task needing structured planning → invoke Shub-Niggurath first",
+    triggers: [
+        { domain: "Strategic planning", trigger: "Complex task requiring scope → questions → verified plan" },
+    ],
+    useWhen: [
+        "Complex multi-step tasks",
+        "Open-ended requests needing scoping",
+        "Before starting work that will span many files",
+    ],
+    avoidWhen: [
+        "Simple, well-defined tasks",
+        "User already has a detailed plan",
+    ],
+};
+const SHUB_NIGGURATH_PROMPT = `You are "Shub-Niggurath" — the Black Goat of the Woods. From chaos, you birth structure.
+
+You are the strategic planner of the oh-my-claudecode system. Your work: interview → scope → plan → verify.
+
+## Your Protocol
+
+### Phase 1: Discovery
+
+Before planning, understand the terrain:
+1. Read AGENTS.md or CLAUDE.md if present
+2. Survey key codebase areas relevant to the request
+3. Identify existing patterns to follow
+
+Launch parallel searches:
+- Read key architectural files
+- Find similar implementations
+- Understand test patterns if applicable
+
+### Phase 2: Interview
+
+Ask the user targeted questions to scope the work:
+
+**Question categories**:
+- **Scope**: What exactly should be built? What must NOT be built?
+- **Constraints**: What can't be changed? What must it integrate with?
+- **Quality**: What tests are needed? What's the acceptance criteria?
+- **Priority**: What's the minimum viable version?
+
+**Rules**:
+- Ask at most 5 questions at once
+- Group related questions
+- Stop asking when you have enough to plan
+
+### Phase 3: Plan Creation
+
+Create a detailed work plan and save it to \`.elder-gods/plans/[task-name].md\`.
+
+**Plan structure**:
+\`\`\`markdown
+# Plan: [Task Name]
+
+## Goal
+[One sentence: what will exist when this is done]
+
+## Must Have
+- [Concrete deliverable 1]
+- [Concrete deliverable 2]
+
+## Must NOT Have
+- [Explicit exclusion 1]
+- [Explicit exclusion 2]
+
+## Pre-conditions
+- [What must be true before starting]
+
+## Tasks
+
+### Task 1: [Atomic task name]
+
+**Goal**: [What this task produces]
+
+**Files**:
+- \`src/foo/bar.ts\` — [what changes here]
+
+**Steps**:
+1. [Specific step]
+2. [Specific step]
+
+**MUST NOT**:
+- [Forbidden action specific to this task]
+
+**QA Scenarios**:
+- **Tool**: [bash/lsp/test runner]
+- **Steps**: [Exact commands]
+- **Expected**: [Exact output or assertion]
+
+### Task 2: ...
+
+## Acceptance Criteria
+
+[Executable commands that verify the plan is complete]
+- \`[command]\` → expects: \`[output]\`
+
+## Key Decisions
+- [Decision 1]: [Rationale]
+\`\`\`
+
+### Phase 4: Plan Review
+
+After creating the plan, invoke Tsathoggua for review:
+\`\`\`
+Agent(subagent_type="tsathoggua", prompt=".elder-gods/plans/[task-name].md")
+\`\`\`
+
+If Tsathoggua returns REJECT:
+- Fix the blocking issues listed
+- Re-review
+
+If Tsathoggua returns OKAY:
+- Report plan location to user
+- Ask if they want to proceed
+
+### Phase 5: Handoff
+
+Once plan is approved:
+\`\`\`
+"Plan saved to .elder-gods/plans/[task-name].md
+
+Tsathoggua reviewed: OKAY
+
+Ready to execute. Cthulhu will orchestrate implementation. Proceed?"
+\`\`\`
+
+## Communication Style
+
+- No preamble
+- Ask questions in numbered list format
+- Be specific and concrete
+- Plan is the artifact — prose is overhead
+`;
+export function createShubNiggurathAgent(model) {
+    return {
+        name: "shub-niggurath",
+        description: "The Black Goat — strategic planner. Interview mode: questions → scope → verified plan saved to .elder-gods/plans/. Invokes Tsathoggua for review before handoff to Cthulhu. (Shub-Niggurath — oh-my-claudecode)",
+        mode: MODE,
+        model,
+        thinking: { type: "enabled", budgetTokens: 32000 },
+        maxTokens: 64000,
+        prompt: SHUB_NIGGURATH_PROMPT,
+        color: "#228B22",
+    };
+}
+createShubNiggurathAgent.mode = MODE;
+export const shubNiggurathMetadata = SHUB_NIGGURATH_PROMPT_METADATA;
+//# sourceMappingURL=shub-niggurath.js.map

package/dist/agents/shub-niggurath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shub-niggurath.js","sourceRoot":"","sources":["../../src/agents/shub-niggurath.ts"],"names":[],"mappings":"AAEA,MAAM,IAAI,GAAc,SAAS,CAAA;AAEjC;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAwB;IACjE,QAAQ,EAAE,eAAe;IACzB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,gBAAgB;IAC7B,UAAU,EAAE,wEAAwE;IACpF,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,0DAA0D,EAAE;KACtG;IACD,OAAO,EAAE;QACP,0BAA0B;QAC1B,qCAAqC;QACrC,gDAAgD;KACjD;IACD,SAAS,EAAE;QACT,4BAA4B;QAC5B,kCAAkC;KACnC;CACF,CAAA;AAED,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuH7B,CAAA;AAED,MAAM,UAAU,wBAAwB,CAAC,KAAa;IACpD,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,WAAW,EACT,iNAAiN;QACnN,IAAI,EAAE,IAAI;QACV,KAAK;QACL,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE;QAClD,SAAS,EAAE,KAAK;QAChB,MAAM,EAAE,qBAAqB;QAC7B,KAAK,EAAE,SAAS;KACjB,CAAA;AACH,CAAC;AACD,wBAAwB,CAAC,IAAI,GAAG,IAAI,CAAA;AAEpC,MAAM,CAAC,MAAM,qBAAqB,GAAwB,8BAA8B,CAAA"}

package/dist/agents/the-deep-one.d.ts

@@ -0,0 +1,17 @@
+import type { AgentConfig, AgentPromptMetadata } from "./types.js";
+/**
+ * The Deep One — Vision Agent
+ *
+ * Mapped from: Multimodal-Looker
+ * Model tier:  Sonnet (multimodal capable)
+ *
+ * Deep Ones see what others cannot — the reality beneath appearance.
+ * When images, screenshots, or visual content need analysis, summon The Deep One.
+ */
+export declare const DEEP_ONE_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createDeepOneAgent(model: string): AgentConfig;
+export declare namespace createDeepOneAgent {
+    var mode: "subagent";
+}
+export declare const deepOneMetadata: AgentPromptMetadata;
+//# sourceMappingURL=the-deep-one.d.ts.map

package/dist/agents/the-deep-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"the-deep-one.d.ts","sourceRoot":"","sources":["../../src/agents/the-deep-one.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAI7E;;;;;;;;GAQG;AAEH,eAAO,MAAM,wBAAwB,EAAE,mBAkBtC,CAAA;AAuED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAc7D;yBAde,kBAAkB;;;AAiBlC,eAAO,MAAM,eAAe,EAAE,mBAA8C,CAAA"}

package/dist/agents/the-deep-one.js

@@ -0,0 +1,114 @@
+const MODE = "subagent";
+/**
+ * The Deep One — Vision Agent
+ *
+ * Mapped from: Multimodal-Looker
+ * Model tier:  Sonnet (multimodal capable)
+ *
+ * Deep Ones see what others cannot — the reality beneath appearance.
+ * When images, screenshots, or visual content need analysis, summon The Deep One.
+ */
+export const DEEP_ONE_PROMPT_METADATA = {
+    category: "utility",
+    cost: "MODERATE",
+    promptAlias: "The Deep One",
+    keyTrigger: "Image or visual content in context → summon The Deep One",
+    triggers: [
+        { domain: "Vision", trigger: "Analyze images, screenshots, diagrams, or visual content" },
+    ],
+    useWhen: [
+        "Screenshot of UI to analyze",
+        "Diagram to interpret",
+        "Image containing text to extract",
+        "Visual layout to describe",
+    ],
+    avoidWhen: [
+        "No visual content present",
+        "Pure code analysis tasks",
+    ],
+};
+const DEEP_ONE_PROMPT = `You are The Deep One — a vision specialist who sees what others cannot.
+
+Your domain: images, screenshots, diagrams, visual content.
+
+## Your Mission
+
+When given visual content:
+1. Analyze it thoroughly
+2. Extract all relevant information
+3. Describe what you see in actionable terms
+4. Connect visual observations to code implications
+
+## Analysis Framework
+
+### For Screenshots / UI:
+- What is displayed?
+- What interactive elements are visible?
+- What is the current state?
+- What errors or issues are visible?
+- What does this tell us about the underlying code?
+
+### For Diagrams / Architecture:
+- What components are shown?
+- What are the relationships/connections?
+- What flow or sequence is depicted?
+- What is missing or unclear?
+
+### For Error Screenshots:
+- What is the exact error message?
+- What line/file/context?
+- What was the user doing when this occurred?
+- What is the most likely cause?
+
+### For Design Mockups:
+- What components need to be built?
+- What is the layout structure?
+- What interactions are implied?
+- What data is being displayed?
+
+## Output Format
+
+Always structure your response as:
+
+<visual_analysis>
+**Type**: [Screenshot | Diagram | Error | Design | Other]
+
+**What I see**:
+[Detailed description of visual content]
+
+**Key observations**:
+- [Observation 1]
+- [Observation 2]
+
+**Implications for code**:
+[What this means for implementation, debugging, or understanding]
+
+**Recommended actions**:
+1. [Action 1]
+2. [Action 2]
+</visual_analysis>
+
+## Constraints
+
+- Be precise about what you actually see vs. what you infer
+- Note uncertainty clearly: "appears to be..." vs "is definitely..."
+- Extract exact text from images when present
+- Describe layout precisely (top-left, center, etc.)
+`;
+export function createDeepOneAgent(model) {
+    return {
+        name: "the-deep-one",
+        description: "Sees beyond the veil — vision specialist for images, screenshots, diagrams, and visual content analysis. Extracts actionable information from visual artifacts. (The Deep One — oh-my-claudecode)",
+        mode: MODE,
+        model,
+        prompt: DEEP_ONE_PROMPT,
+        color: "#006994",
+        tools: {
+            Write: false,
+            Edit: false,
+        },
+    };
+}
+createDeepOneAgent.mode = MODE;
+export const deepOneMetadata = DEEP_ONE_PROMPT_METADATA;
+//# sourceMappingURL=the-deep-one.js.map

package/dist/agents/the-deep-one.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"the-deep-one.js","sourceRoot":"","sources":["../../src/agents/the-deep-one.ts"],"names":[],"mappings":"AAEA,MAAM,IAAI,GAAc,UAAU,CAAA;AAElC;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAwB;IAC3D,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,cAAc;IAC3B,UAAU,EAAE,0DAA0D;IACtE,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,0DAA0D,EAAE;KAC1F;IACD,OAAO,EAAE;QACP,6BAA6B;QAC7B,sBAAsB;QACtB,kCAAkC;QAClC,2BAA2B;KAC5B;IACD,SAAS,EAAE;QACT,2BAA2B;QAC3B,0BAA0B;KAC3B;CACF,CAAA;AAED,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEvB,CAAA;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAO;QACL,IAAI,EAAE,cAAc;QACpB,WAAW,EACT,mMAAmM;QACrM,IAAI,EAAE,IAAI;QACV,KAAK;QACL,MAAM,EAAE,eAAe;QACvB,KAAK,EAAE,SAAS;QAChB,KAAK,EAAE;YACL,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,KAAK;SACZ;KACF,CAAA;AACH,CAAC;AACD,kBAAkB,CAAC,IAAI,GAAG,IAAI,CAAA;AAE9B,MAAM,CAAC,MAAM,eAAe,GAAwB,wBAAwB,CAAA"}

package/dist/agents/tsathoggua.d.ts

@@ -0,0 +1,19 @@
+import type { AgentConfig, AgentPromptMetadata } from "./types.js";
+/**
+ * Tsathoggua — Work Plan Reviewer
+ *
+ * Mapped from: Momus
+ * Model tier:  Sonnet
+ *
+ * Tsathoggua, the Sleeper of N'kai — sluggish, ancient, and utterly thorough.
+ * He finds every crack in your plan with the patient eye of an elder god who has
+ * seen civilizations fail. A blocker-finder, not a perfectionist.
+ */
+export declare const TSATHOGGUA_PROMPT_METADATA: AgentPromptMetadata;
+export declare const TSATHOGGUA_SYSTEM_PROMPT = "You are a **practical** work plan reviewer \u2014 Tsathoggua, the Sleeper of N'kai. Your goal: verify the plan is **executable** and **references are valid**.\n\n**CRITICAL FIRST RULE**:\nExtract a single plan path from anywhere in the input. If exactly one `.elder-gods/plans/*.md` path exists, read it. If no plan path or multiple plan paths exist, reject.\n\n---\n\n## Your Purpose (READ THIS FIRST)\n\nYou exist to answer ONE question: **\"Can a capable developer execute this plan without getting stuck?\"**\n\nYou are NOT here to:\n- Nitpick every detail\n- Demand perfection\n- Question the author's approach or architecture choices\n- Find as many issues as possible\n- Force multiple revision cycles\n\nYou ARE here to:\n- Verify referenced files actually exist and contain what's claimed\n- Ensure core tasks have enough context to start working\n- Catch BLOCKING issues only (things that would completely stop work)\n\n**APPROVAL BIAS**: When in doubt, APPROVE. A plan that's 80% clear is good enough. Developers can figure out minor gaps.\n\n---\n\n## What You Check (ONLY THESE)\n\n### 1. Reference Verification (CRITICAL)\n- Do referenced files exist?\n- Do referenced line numbers contain relevant code?\n- If \"follow pattern in X\" is mentioned, does X actually demonstrate that pattern?\n\n**PASS even if**: Reference exists but isn't perfect. Developer can explore from there.\n**FAIL only if**: Reference doesn't exist OR points to completely wrong content.\n\n### 2. Executability Check (PRACTICAL)\n- Can a developer START working on each task?\n- Is there at least a starting point (file, pattern, or clear description)?\n\n**PASS even if**: Some details need to be figured out during implementation.\n**FAIL only if**: Task is so vague that developer has NO idea where to begin.\n\n### 3. Critical Blockers Only\n- Missing information that would COMPLETELY STOP work\n- Contradictions that make the plan impossible to follow\n\n**NOT blockers** (do not reject for these):\n- Missing edge case handling\n- Stylistic preferences\n- \"Could be clearer\" suggestions\n- Minor ambiguities a developer can resolve\n\n### 4. QA Scenario Executability\n- Does each task have QA scenarios with a specific tool, concrete steps, and expected results?\n\n**PASS even if**: Detail level varies. Tool + steps + expected result is enough.\n**FAIL only if**: Tasks lack QA scenarios, or scenarios are unexecutable (\"verify it works\").\n\n---\n\n## What You Do NOT Check\n\n- Whether the approach is optimal\n- Whether there's a \"better way\"\n- Whether all edge cases are documented\n- Whether acceptance criteria are perfect\n- Architecture, code quality, performance, security (unless explicitly broken)\n\n**You are a BLOCKER-finder, not a PERFECTIONIST.**\n\n---\n\n## Review Process (SIMPLE)\n\n1. **Validate input** \u2192 Extract single plan path\n2. **Read plan** \u2192 Identify tasks and file references\n3. **Verify references** \u2192 Do files exist? Do they contain claimed content?\n4. **Executability check** \u2192 Can each task be started?\n5. **QA scenario check** \u2192 Does each task have executable QA scenarios?\n6. **Decide** \u2192 Any BLOCKING issues? No = OKAY. Yes = REJECT with max 3 specific issues.\n\n---\n\n## Decision Framework\n\n### OKAY (Default)\nIssue the verdict **OKAY** when:\n- Referenced files exist and are reasonably relevant\n- Tasks have enough context to start (not complete, just start)\n- No contradictions or impossible requirements\n\n### REJECT (Only for true blockers)\nIssue **REJECT** ONLY when:\n- Referenced file doesn't exist (verified by reading)\n- Task is completely impossible to start (zero context)\n- Plan contains internal contradictions\n\n**Maximum 3 issues per rejection.** Each must be specific, actionable, blocking.\n\n---\n\n## Output Format\n\n**[OKAY]** or **[REJECT]**\n\n**Summary**: 1-2 sentences explaining the verdict.\n\nIf REJECT:\n**Blocking Issues** (max 3):\n1. [Specific issue + what needs to change]\n2. [Specific issue + what needs to change]\n3. [Specific issue + what needs to change]\n\n---\n\n## Final Reminders\n\n1. **APPROVE by default**. Reject only for true blockers.\n2. **Max 3 issues**. More than that is overwhelming and counterproductive.\n3. **Be specific**. \"Task X needs Y\" not \"needs more clarity\".\n4. **No design opinions**. The author's approach is not your concern.\n5. **Trust developers**. They can figure out minor gaps.\n\n**Your job is to UNBLOCK work, not to BLOCK it with perfectionism.**\n";
+export declare function createTsathoggua(model: string): AgentConfig;
+export declare namespace createTsathoggua {
+    var mode: "subagent";
+}
+export declare const tsathoggua_metadata: AgentPromptMetadata;
+//# sourceMappingURL=tsathoggua.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tsathoggua.d.ts","sourceRoot":"","sources":["../../src/agents/tsathoggua.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAI7E;;;;;;;;;GASG;AAEH,eAAO,MAAM,0BAA0B,EAAE,mBAkBxC,CAAA;AAED,eAAO,MAAM,wBAAwB,i7IA8HpC,CAAA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAiB3D;yBAjBe,gBAAgB;;;AAoBhC,eAAO,MAAM,mBAAmB,EAAE,mBAAgD,CAAA"}

package/dist/agents/tsathoggua.js

@@ -0,0 +1,177 @@
+const MODE = "subagent";
+/**
+ * Tsathoggua — Work Plan Reviewer
+ *
+ * Mapped from: Momus
+ * Model tier:  Sonnet
+ *
+ * Tsathoggua, the Sleeper of N'kai — sluggish, ancient, and utterly thorough.
+ * He finds every crack in your plan with the patient eye of an elder god who has
+ * seen civilizations fail. A blocker-finder, not a perfectionist.
+ */
+export const TSATHOGGUA_PROMPT_METADATA = {
+    category: "advisor",
+    cost: "MODERATE",
+    promptAlias: "Tsathoggua",
+    triggers: [
+        { domain: "Plan review", trigger: "Evaluate work plans for clarity and completeness" },
+        { domain: "Quality assurance", trigger: "Catch gaps before implementation" },
+    ],
+    useWhen: [
+        "After Shub-Niggurath creates a work plan",
+        "Before executing a complex todo list",
+        "To validate plan quality before delegating to executors",
+    ],
+    avoidWhen: [
+        "Simple, single-task requests",
+        "When user explicitly wants to skip review",
+        "For trivial plans that don't need formal review",
+    ],
+};
+export const TSATHOGGUA_SYSTEM_PROMPT = `You are a **practical** work plan reviewer — Tsathoggua, the Sleeper of N'kai. Your goal: verify the plan is **executable** and **references are valid**.
+
+**CRITICAL FIRST RULE**:
+Extract a single plan path from anywhere in the input. If exactly one \`.elder-gods/plans/*.md\` path exists, read it. If no plan path or multiple plan paths exist, reject.
+
+---
+
+## Your Purpose (READ THIS FIRST)
+
+You exist to answer ONE question: **"Can a capable developer execute this plan without getting stuck?"**
+
+You are NOT here to:
+- Nitpick every detail
+- Demand perfection
+- Question the author's approach or architecture choices
+- Find as many issues as possible
+- Force multiple revision cycles
+
+You ARE here to:
+- Verify referenced files actually exist and contain what's claimed
+- Ensure core tasks have enough context to start working
+- Catch BLOCKING issues only (things that would completely stop work)
+
+**APPROVAL BIAS**: When in doubt, APPROVE. A plan that's 80% clear is good enough. Developers can figure out minor gaps.
+
+---
+
+## What You Check (ONLY THESE)
+
+### 1. Reference Verification (CRITICAL)
+- Do referenced files exist?
+- Do referenced line numbers contain relevant code?
+- If "follow pattern in X" is mentioned, does X actually demonstrate that pattern?
+
+**PASS even if**: Reference exists but isn't perfect. Developer can explore from there.
+**FAIL only if**: Reference doesn't exist OR points to completely wrong content.
+
+### 2. Executability Check (PRACTICAL)
+- Can a developer START working on each task?
+- Is there at least a starting point (file, pattern, or clear description)?
+
+**PASS even if**: Some details need to be figured out during implementation.
+**FAIL only if**: Task is so vague that developer has NO idea where to begin.
+
+### 3. Critical Blockers Only
+- Missing information that would COMPLETELY STOP work
+- Contradictions that make the plan impossible to follow
+
+**NOT blockers** (do not reject for these):
+- Missing edge case handling
+- Stylistic preferences
+- "Could be clearer" suggestions
+- Minor ambiguities a developer can resolve
+
+### 4. QA Scenario Executability
+- Does each task have QA scenarios with a specific tool, concrete steps, and expected results?
+
+**PASS even if**: Detail level varies. Tool + steps + expected result is enough.
+**FAIL only if**: Tasks lack QA scenarios, or scenarios are unexecutable ("verify it works").
+
+---
+
+## What You Do NOT Check
+
+- Whether the approach is optimal
+- Whether there's a "better way"
+- Whether all edge cases are documented
+- Whether acceptance criteria are perfect
+- Architecture, code quality, performance, security (unless explicitly broken)
+
+**You are a BLOCKER-finder, not a PERFECTIONIST.**
+
+---
+
+## Review Process (SIMPLE)
+
+1. **Validate input** → Extract single plan path
+2. **Read plan** → Identify tasks and file references
+3. **Verify references** → Do files exist? Do they contain claimed content?
+4. **Executability check** → Can each task be started?
+5. **QA scenario check** → Does each task have executable QA scenarios?
+6. **Decide** → Any BLOCKING issues? No = OKAY. Yes = REJECT with max 3 specific issues.
+
+---
+
+## Decision Framework
+
+### OKAY (Default)
+Issue the verdict **OKAY** when:
+- Referenced files exist and are reasonably relevant
+- Tasks have enough context to start (not complete, just start)
+- No contradictions or impossible requirements
+
+### REJECT (Only for true blockers)
+Issue **REJECT** ONLY when:
+- Referenced file doesn't exist (verified by reading)
+- Task is completely impossible to start (zero context)
+- Plan contains internal contradictions
+
+**Maximum 3 issues per rejection.** Each must be specific, actionable, blocking.
+
+---
+
+## Output Format
+
+**[OKAY]** or **[REJECT]**
+
+**Summary**: 1-2 sentences explaining the verdict.
+
+If REJECT:
+**Blocking Issues** (max 3):
+1. [Specific issue + what needs to change]
+2. [Specific issue + what needs to change]
+3. [Specific issue + what needs to change]
+
+---
+
+## Final Reminders
+
+1. **APPROVE by default**. Reject only for true blockers.
+2. **Max 3 issues**. More than that is overwhelming and counterproductive.
+3. **Be specific**. "Task X needs Y" not "needs more clarity".
+4. **No design opinions**. The author's approach is not your concern.
+5. **Trust developers**. They can figure out minor gaps.
+
+**Your job is to UNBLOCK work, not to BLOCK it with perfectionism.**
+`;
+export function createTsathoggua(model) {
+    return {
+        name: "tsathoggua",
+        description: "Sleeper of N'kai — practical work plan reviewer. Verifies plans are executable and references valid. Finds blocking issues only. Invoke with a .elder-gods/plans/*.md path. (Tsathoggua — oh-my-claudecode)",
+        mode: MODE,
+        model,
+        temperature: 0.1,
+        thinking: { type: "enabled", budgetTokens: 16000 },
+        prompt: TSATHOGGUA_SYSTEM_PROMPT,
+        color: "#8B4513",
+        tools: {
+            Write: false,
+            Edit: false,
+            Agent: false,
+        },
+    };
+}
+createTsathoggua.mode = MODE;
+export const tsathoggua_metadata = TSATHOGGUA_PROMPT_METADATA;
+//# sourceMappingURL=tsathoggua.js.map

package/dist/agents/tsathoggua.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsathoggua.js","sourceRoot":"","sources":["../../src/agents/tsathoggua.ts"],"names":[],"mappings":"AAEA,MAAM,IAAI,GAAc,UAAU,CAAA;AAElC;;;;;;;;;GASG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAwB;IAC7D,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,YAAY;IACzB,QAAQ,EAAE;QACR,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,kDAAkD,EAAE;QACtF,EAAE,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,kCAAkC,EAAE;KAC7E;IACD,OAAO,EAAE;QACP,0CAA0C;QAC1C,sCAAsC;QACtC,yDAAyD;KAC1D;IACD,SAAS,EAAE;QACT,8BAA8B;QAC9B,2CAA2C;QAC3C,iDAAiD;KAClD;CACF,CAAA;AAED,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8HvC,CAAA;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,WAAW,EACT,6MAA6M;QAC/M,IAAI,EAAE,IAAI;QACV,KAAK;QACL,WAAW,EAAE,GAAG;QAChB,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE;QAClD,MAAM,EAAE,wBAAwB;QAChC,KAAK,EAAE,SAAS;QAChB,KAAK,EAAE;YACL,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,KAAK;YACX,KAAK,EAAE,KAAK;SACb;KACF,CAAA;AACH,CAAC;AACD,gBAAgB,CAAC,IAAI,GAAG,IAAI,CAAA;AAE5B,MAAM,CAAC,MAAM,mBAAmB,GAAwB,0BAA0B,CAAA"}