lazyopencode-core 0.0.1

package/ATTRIBUTION.md

@@ -0,0 +1,38 @@
+# Attribution
+
+@lazyopencode/core is a hard fork and fusion of multiple open-source projects. We thank the original authors.
+
+## Agent orchestration
+
+Forked and rewritten from **[oh-my-opencode-slim](https://github.com/alvinunreal/oh-my-opencode-slim)** by Alvin Unreal (MIT).
+
+The original project provided a lightweight multi-agent routing shape. LazyOpenCode renames the public surface under the `lazy-*` namespace and rewrites the prompts around scope governance, ponytail discipline, and workflow closure.
+
+## Workflow skills
+
+Forked and rewritten from **[Matt Pocock skills](https://github.com/mattpocock)** (MIT):
+- `grilling` → `lazy/grill`
+- `to-prd` → `lazy/specify`
+- `to-issues` → `lazy/plan`
+- `tdd` + `implement` → `lazy/build`
+- `diagnosing-bugs` → `lazy/debug`
+
+Forked from **oh-my-opencode-slim** (MIT):
+- `simplify` → `lazy/simplify`
+- `worktrees` → `lazy/worktree`
+
+Forked and rewritten from **[opencode-power-pack](https://github.com/waybarrios/opencode-power-pack)** by Way Barrios (MIT), originally ported from Anthropic's Claude Code plugins:
+- `code-review` → `lazy/review`
+- `security-review` → `lazy/security`
+
+## Philosophy
+
+The ponytail philosophy and constraint system is from **[ponytail](https://github.com/ponytail)**.
+
+## Hook infrastructure
+
+Hook patterns (system transform, messages transform, chat routing, task session management, error recovery) are adapted from oh-my-opencode-slim's plugin architecture, with significant simplification.
+
+## License
+
+MIT — same as all upstream projects.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lazyopencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,357 @@
+# LazyOpenCode
+
+Zero-config governed team runtime for AI coding in OpenCode.
+
+LazyOpenCode turns OpenCode into a governed AI coding team. It includes a primary
+runtime coordinator, focused subagents, workflow skills, risk gates, background
+job tracking, context budgets, destructive-action guardrails, and close reports.
+The product goal is simple: keep AI coding scoped, visible, budgeted, and
+reviewed without making users assemble their own OpenCode setup.
+
+> Full manual: [docs/user-manual.md](docs/user-manual.md)
+> Architecture: [docs/architecture.md](docs/architecture.md)
+> Product audit: [docs/product-audit.md](docs/product-audit.md)
+> Work plan: [docs/work-plan.md](docs/work-plan.md)
+> Council: [docs/council.md](docs/council.md)
+> OpenCode integration: [docs/opencode-integration.md](docs/opencode-integration.md)
+> Desktop distribution: [docs/desktop-distribution.md](docs/desktop-distribution.md)
+
+## Why
+
+AI coding often overbuilds, drifts away from the request, launches work that is hard to reconcile, and stops before review. LazyOpenCode makes those failure modes explicit:
+
+- classify the task before implementation
+- gate vague or high-risk work until scope is clear
+- track background jobs and reusable sessions
+- close work with review, simplify, and verification
+- ask before destructive commands
+
+## Is It Zero Config?
+
+Yes for the core plugin. After OpenCode loads `@lazyopencode/core`, LazyOpenCode
+registers its primary agent, subagents, workflow skills, `/lazy` commands,
+permission guard, job board, token budget, council guard, persistence, doctor,
+and close report defaults.
+
+You do **not** need to configure providers, models, auth, MCP, or project
+settings for LazyOpenCode. It preserves your existing OpenCode setup.
+
+Desktop is not required. LazyOpenCode Desktop is a later `0.1.0` distribution
+stage.
+
+## Install From npm
+
+Prerequisite: OpenCode is installed and connected to at least one model provider.
+
+Add the plugin to your OpenCode config:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@lazyopencode/core"]
+}
+```
+
+Use a global config if you want LazyOpenCode everywhere:
+
+```text
+~/.config/opencode/opencode.jsonc
+```
+
+Use a project config if you want it only for one repo:
+
+```text
+opencode.json
+```
+
+OpenCode installs npm plugins automatically on startup. Scoped npm packages are
+supported.
+
+OpenCode also accepts `~/.config/opencode/opencode.json` if you prefer JSON
+without comments.
+
+Then start OpenCode in your project:
+
+```bash
+opencode
+```
+
+Run the health check:
+
+```text
+/lazy doctor
+```
+
+## Try From This Repository
+
+Use this path before the package is published, or when developing LazyOpenCode
+itself.
+
+Build the package:
+
+```bash
+cd packages/lazyopencode-core
+npm run build
+```
+
+Create a local OpenCode plugin file in the project where you want to test it:
+
+```bash
+mkdir -p .opencode/plugins
+```
+
+```js
+// .opencode/plugins/lazyopencode.js
+import { LazyOpenCodePlugin } from "/absolute/path/to/lazyopencode/packages/lazyopencode-core/dist/index.js"
+
+export const LazyOpenCode = LazyOpenCodePlugin
+```
+
+Replace `/absolute/path/to/lazyopencode` with your local checkout path.
+
+Then start OpenCode:
+
+```bash
+opencode
+```
+
+Check it loaded:
+
+```text
+/lazy doctor
+```
+
+## First Run
+
+Start a task through LazyOpenCode instead of asking OpenCode to immediately
+build:
+
+```text
+/lazy start add user registration
+```
+
+LazyOpenCode classifies the task and chooses the next workflow stage:
+
+```text
+LAZY START
+Task: add user registration
+Decision: nudge medium
+Stage: plan
+Next: lazy/specify
+```
+
+During work, inspect state:
+
+```text
+/lazy status
+```
+
+Before finishing, close the loop:
+
+```text
+/lazy close
+```
+
+If LazyOpenCode did not observe a fact automatically, record it explicitly:
+
+```text
+/lazy behavior Registration now validates email before submit
+/lazy risk Password reset flow not touched
+/lazy verify pass
+```
+
+## Optional Config
+
+No `lazyopencode` config block is required. The block below only customizes
+defaults. LazyOpenCode Desktop will preinstall the plugin and defaults in the
+future distribution.
+
+Full optional config:
+
+```json
+{
+  "lazyopencode": {
+    "sdk": {
+      "mode": "v2",
+      "legacyHookAdapter": true
+    },
+    "takeover": "governed",
+    "mode": "governor",
+    "maxSessionsPerAgent": 2,
+    "maxActiveTaskDepth": 4,
+    "maxMessages": 80,
+    "permissionGuard": true,
+    "persistence": {},
+    "workflowGate": true,
+    "ponytailMode": true,
+    "opencode": {
+      "sessionStatus": true,
+      "vcsDiff": true,
+      "todos": true,
+      "permissions": true,
+      "worktreeIsolation": "risky-only",
+      "revertCheckpoints": true
+    },
+    "closeReport": {
+      "autoCollect": true,
+      "maxItems": 5
+    },
+    "council": {
+      "enabled": true,
+      "eligibility": "guarded",
+      "default_preset": "code-review",
+      "maxCouncillors": 3,
+      "presets": {
+        "code-review": {
+          "reasoner": { "model": "openai/o3" },
+          "critic": { "model": "anthropic/claude-opus-4" }
+        }
+      }
+    }
+  }
+}
+```
+
+## What You Get
+
+Install one line and get a governed AI coding workspace: one primary runtime
+coordinator, focused subagents, workflow skills, destructive-action guardrails,
+token budget controls, and optional council escalation.
+
+### Trivial fix → direct execution
+
+```
+> fix the typo in footer.ts line 12
+[Lazy scope: trivial. Goes straight to build.]
+```
+
+LazyOpenCode detects well-bounded work and lets it run without ceremony.
+
+### Medium feature → grilling + spec + plan + build + review
+
+```
+> /lazy start add user registration
+[Lazy nudge: medium. Suggested next step: load lazy/specify.]
+```
+
+Each stage gates the next — no build before spec, no review before build.
+
+### Broad/risky request → blocked until scoped
+
+```
+> 全面优化这个项目
+[Lazy gate: ambiguous. Need scope, success criteria, must-not-break list.]
+```
+
+The gate stays closed until the task is sharpened. Say "just do it" to override.
+
+## Deepwork Mode
+
+```
+> /lazy deepwork refactor auth service
+```
+
+Injects a focused, single-goal system prompt: no ponytail philosophy, no delegation rules, no job board — just one agent, one task, zero context noise. Use for deep maintenance or audit work.
+
+## Commands
+
+```
+/lazy start <task>           Classify and gate a task
+/lazy status                 Show mode, workflow stage, jobs, sessions
+/lazy reset                  Clear runtime state for current scope
+/lazy mode <mode>            Change governance mode
+/lazy explain                Explain last gate decision
+/lazy review                 Start review closure
+/lazy simplify               Start simplification pass
+/lazy debug <msg>            Start systematic debugging
+/lazy close                  Produce close report and shutdown checklist
+/lazy doctor                 Check plugin health and OpenCode integration
+/lazy verify <pass|fail|pending>
+/lazy risk <text>            Add remaining risk to close report
+/lazy behavior <text>        Add changed behavior to close report
+/lazy deepwork <task>        Start deepwork flow
+```
+
+## Agents
+
+| Agent | Mode | Role |
+|-------|------|------|
+| `lazy` | primary | Runtime coordinator — classify, gate, delegate, track, close |
+| `lazy-explorer` | subagent | Fast codebase recon (glob, grep, AST) |
+| `lazy-oracle` | subagent | Architecture, debugging, review, council orchestration |
+| `lazy-councillor` | subagent | Independent judgment for council sessions |
+| `lazy-librarian` | subagent | External docs, API references, web research |
+| `lazy-fixer` | subagent | Bounded mechanical implementation |
+| `lazy-designer` | subagent | UI/UX design, layout, responsive systems |
+| `lazy-observer` | subagent | Image, screenshot, PDF, diagram analysis |
+
+## Skills
+
+Nine built-in workflow skills (load via `load lazy/<name>`):
+
+| Skill | Purpose |
+|-------|---------|
+| `lazy/grill` | Interview to sharpen requirements |
+| `lazy/specify` | Turn discussion into PRD |
+| `lazy/plan` | Break PRD into tracer-bullet issues |
+| `lazy/build` | Implement one issue, test-first, YAGNI-gated |
+| `lazy/review` | Code review — find bugs, suggest deletions |
+| `lazy/debug` | Systematic diagnosis for hard bugs |
+| `lazy/simplify` | Find what to delete |
+| `lazy/worktree` | Git worktrees for isolation |
+| `lazy/security` | OWASP audit |
+
+## Council
+
+The **council** system runs multiple LLM agents independently on the same question,
+then the oracle synthesizes a final recommendation. Use for high-risk decisions,
+ambiguous bugs, or architecture with long-term impact.
+
+Council is an optional escalation path. It is not part of the default happy path,
+and it is guarded by workflow eligibility plus `maxCouncillors`.
+
+See [docs/council.md](docs/council.md).
+
+## Modes
+
+- `off`: track state only
+- `coach`: nudge, never block
+- `governor`: block high-risk and ambiguous work, nudge medium (default)
+- `strict`: block medium, high-risk, and ambiguous work
+
+## How It Differs
+
+Ponytail is the engineering philosophy: YAGNI, deletion first, stdlib first, fewer lines. LazyOpenCode is the runtime governor that applies that philosophy to OpenCode sessions.
+
+Compared with lightweight agent-routing plugins, LazyOpenCode includes the team
+runtime but treats routing as one part of a larger lifecycle: classify, gate,
+delegate, track, budget, review, and close.
+
+Compared with autonomous coding assistants, LazyOpenCode stays OpenCode-native
+and optimizes for controlled engineering work: smaller scope, clearer gates,
+bounded budgets, visible delegation, and reliable closure.
+
+## Token Control
+
+- sliding-window message pruning with `lazyopencode.maxMessages` (default `80`)
+- image attachments are saved to files and replaced with paths for `@lazy-observer`
+- available skills are filtered for the `lazy` primary agent
+- background job status is summarized instead of pasting full subagent context
+- `/lazy status` shows message-count budget, last prune, and job board mode
+
+## OpenCode Integration
+
+The npm package defaults to the OpenCode v2 registration surface and keeps the
+legacy hook adapter enabled for current chat, message, permission, command, and
+tool governance. Deno is only the maintainer toolchain; OpenCode still loads
+`dist/index.js` from the npm package.
+
+## OpenCode Desktop
+
+LazyOpenCode Desktop is the planned `0.1.0` distribution stage: OpenCode Desktop
+with `@lazyopencode/core` bundled and enabled by default. The plugin remains the
+source of truth; Desktop handles defaults, health, packaging, and discoverability.
+
+## Status
+
+`0.0.1` is an early, opinionated runtime. Internal module paths are not stable. The public surface is the OpenCode plugin, bundled lazy skills, and `/lazy` command namespace.

package/dist/agents/councillor.d.ts

@@ -0,0 +1 @@
+export declare const COUNCILLOR_PROMPT = "<Role>\nYou are a member of a coding council. You provide independent analysis on a question or code review.\nYou do NOT coordinate with other councillors. Your response is your own.\nBe concise. Cite specific file paths and line numbers when referencing code.\nIf you cannot answer, say so clearly.\n</Role>\n\n## Tools (read-only only)\n- Read, Glob, Grep, list\n\n## Prohibited\n- Write, Edit, Shell, Task, Bash\n- Do NOT create or modify any files\n- Do NOT run any commands";

package/dist/agents/councillor.js

@@ -0,0 +1,14 @@
+export const COUNCILLOR_PROMPT = `<Role>
+You are a member of a coding council. You provide independent analysis on a question or code review.
+You do NOT coordinate with other councillors. Your response is your own.
+Be concise. Cite specific file paths and line numbers when referencing code.
+If you cannot answer, say so clearly.
+</Role>
+
+## Tools (read-only only)
+- Read, Glob, Grep, list
+
+## Prohibited
+- Write, Edit, Shell, Task, Bash
+- Do NOT create or modify any files
+- Do NOT run any commands`;

package/dist/agents/designer.d.ts

@@ -0,0 +1 @@
+export declare const DESIGNER_PROMPT = "<Role>\nYou are a UI/UX design and implementation specialist. You own visual and interaction quality: layout, hierarchy, spacing, motion, affordances, responsive behavior, and overall feel. You create polished, intentional user-facing interfaces.\n</Role>\n\n## Strengths\n- Visual hierarchy and layout composition\n- Responsive design across breakpoints\n- Design systems and component consistency\n- Animations, micro-interactions, transitions\n- Affordances and interaction patterns\n- Color, typography, spacing systems\n\n## Rules\n- Design with intent \u2014 every pixel has a reason.\n- Avoid generic AI aesthetics (overused patterns, bland layouts).\n- Prefer CSS-native over JS-driven animation when possible.\n- Copy is not your strength. Use grounded, normal wording.\n- The lazy runtime coordinator will review and fix copy after your work.\n\n## When delegated to you\n- User-facing interfaces needing polish\n- Responsive layouts\n- UX-critical components (forms, nav, dashboards)\n- Visual consistency across a system\n- Landing or marketing pages\n\n## When NOT delegated to you\n- Backend logic with no visual impact\n- Quick prototypes where design doesn't matter yet\n- Pure data transformations\n";

package/dist/agents/designer.js

@@ -0,0 +1,31 @@
+export const DESIGNER_PROMPT = `<Role>
+You are a UI/UX design and implementation specialist. You own visual and interaction quality: layout, hierarchy, spacing, motion, affordances, responsive behavior, and overall feel. You create polished, intentional user-facing interfaces.
+</Role>
+
+## Strengths
+- Visual hierarchy and layout composition
+- Responsive design across breakpoints
+- Design systems and component consistency
+- Animations, micro-interactions, transitions
+- Affordances and interaction patterns
+- Color, typography, spacing systems
+
+## Rules
+- Design with intent — every pixel has a reason.
+- Avoid generic AI aesthetics (overused patterns, bland layouts).
+- Prefer CSS-native over JS-driven animation when possible.
+- Copy is not your strength. Use grounded, normal wording.
+- The lazy runtime coordinator will review and fix copy after your work.
+
+## When delegated to you
+- User-facing interfaces needing polish
+- Responsive layouts
+- UX-critical components (forms, nav, dashboards)
+- Visual consistency across a system
+- Landing or marketing pages
+
+## When NOT delegated to you
+- Backend logic with no visual impact
+- Quick prototypes where design doesn't matter yet
+- Pure data transformations
+`;

package/dist/agents/explorer.d.ts

@@ -0,0 +1 @@
+export declare const EXPLORER_PROMPT = "<Role>\nYou are a fast codebase explorer. Find files, patterns, and symbols. Answer \"where is X?\" and \"what exists?\" quickly. Return compressed context \u2014 paths, line numbers, summaries. Do not paste entire files unless asked.\n</Role>\n\n## Rules\n- Use glob, grep, ast_grep_search for discovery.\n- Use read for actual content only when needed.\n- Be fast. Two parallel searches beat one sequential search.\n- Find enough to answer, don't exhaust every path.\n- When in doubt, return a map (file tree + key symbols), not raw content.\n\n## Output\n- File paths with line numbers (`src/app.ts:42`)\n- Brief summaries, not essays\n- One-line answers when one line suffices";

package/dist/agents/explorer.js

@@ -0,0 +1,15 @@
+export const EXPLORER_PROMPT = `<Role>
+You are a fast codebase explorer. Find files, patterns, and symbols. Answer "where is X?" and "what exists?" quickly. Return compressed context — paths, line numbers, summaries. Do not paste entire files unless asked.
+</Role>
+
+## Rules
+- Use glob, grep, ast_grep_search for discovery.
+- Use read for actual content only when needed.
+- Be fast. Two parallel searches beat one sequential search.
+- Find enough to answer, don't exhaust every path.
+- When in doubt, return a map (file tree + key symbols), not raw content.
+
+## Output
+- File paths with line numbers (\`src/app.ts:42\`)
+- Brief summaries, not essays
+- One-line answers when one line suffices`;

package/dist/agents/fixer.d.ts

@@ -0,0 +1 @@
+export declare const FIXER_PROMPT = "<Role>\nYou are a fast implementation specialist. You execute well-defined code changes efficiently. You do not research, architect, or design \u2014 you receive complete context and a clear task spec, and you implement it.\n</Role>\n\n## Ponytail constraints (always active)\n- Stdlib over dependency. Native over library. One line over fifty.\n- No abstractions without request. No scaffolding \"for later.\"\n- Deletion over addition. Shortest working diff.\n- Mark deliberate simplifications with `ponytail:` comment.\n- If the spec asks for something over-engineered, flag it (one line) then implement the spec.\n\n## Rules\n- Write code, not explanations.\n- No research. No architectural decisions.\n- No delegation. You are the terminal executor.\n- Single small change (<20 lines, one file) \u2192 done in one shot.\n- Multi-file change \u2192 parallelize, don't serialize.\n\n## Output discipline\n- Code first.\n- No summary unless asked.\n- Pattern: `[code] \u2192 skipped: X, add when Y.`\n";

package/dist/agents/fixer.js

@@ -0,0 +1,23 @@
+export const FIXER_PROMPT = `<Role>
+You are a fast implementation specialist. You execute well-defined code changes efficiently. You do not research, architect, or design — you receive complete context and a clear task spec, and you implement it.
+</Role>
+
+## Ponytail constraints (always active)
+- Stdlib over dependency. Native over library. One line over fifty.
+- No abstractions without request. No scaffolding "for later."
+- Deletion over addition. Shortest working diff.
+- Mark deliberate simplifications with \`ponytail:\` comment.
+- If the spec asks for something over-engineered, flag it (one line) then implement the spec.
+
+## Rules
+- Write code, not explanations.
+- No research. No architectural decisions.
+- No delegation. You are the terminal executor.
+- Single small change (<20 lines, one file) → done in one shot.
+- Multi-file change → parallelize, don't serialize.
+
+## Output discipline
+- Code first.
+- No summary unless asked.
+- Pattern: \`[code] → skipped: X, add when Y.\`
+`;

package/dist/agents/index.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export declare function createAgents(): Record<string, AgentConfig>;

package/dist/agents/index.js

@@ -0,0 +1,55 @@
+import { LAZY_PROMPT } from "./lazy.js";
+import { EXPLORER_PROMPT } from "./explorer.js";
+import { ORACLE_PROMPT } from "./oracle.js";
+import { LIBRARIAN_PROMPT } from "./librarian.js";
+import { DESIGNER_PROMPT } from "./designer.js";
+import { FIXER_PROMPT } from "./fixer.js";
+import { OBSERVER_PROMPT } from "./observer.js";
+import { COUNCILLOR_PROMPT } from "./councillor.js";
+export function createAgents() {
+    return {
+        lazy: {
+            prompt: LAZY_PROMPT,
+            description: "Runtime coordinator: classify, gate, delegate, track, and close AI coding work. Ponytail philosophy default.",
+            mode: "primary",
+            tools: { cancel_task: true },
+        },
+        "lazy-explorer": {
+            prompt: EXPLORER_PROMPT,
+            description: "Fast codebase reconnaissance via glob, grep, AST search. Returns compressed context.",
+            mode: "subagent",
+        },
+        "lazy-oracle": {
+            prompt: ORACLE_PROMPT,
+            description: "Strategic technical advisor for architecture, debugging, review, simplification. YAGNI-first.",
+            mode: "subagent",
+            tools: { council_session: true },
+        },
+        "lazy-councillor": {
+            prompt: COUNCILLOR_PROMPT,
+            description: "Single-model independent judgment worker for council sessions.",
+            mode: "subagent",
+        },
+        "lazy-librarian": {
+            prompt: LIBRARIAN_PROMPT,
+            description: "External documentation, API references, web research via context7 and GitHub code search.",
+            mode: "subagent",
+        },
+        "lazy-designer": {
+            prompt: DESIGNER_PROMPT,
+            temperature: 0.7,
+            description: "Visual and interaction design specialist. Layout, hierarchy, motion, responsive systems.",
+            mode: "subagent",
+        },
+        "lazy-fixer": {
+            prompt: FIXER_PROMPT,
+            description: "Fast mechanical code execution. Ponytail: stdlib first, one line over fifty.",
+            mode: "subagent",
+        },
+        "lazy-observer": {
+            prompt: OBSERVER_PROMPT,
+            description: "Reads images, screenshots, PDFs, diagrams. Returns structured objective observations.",
+            mode: "subagent",
+        },
+    };
+}

package/dist/agents/lazy.d.ts

@@ -0,0 +1 @@
+export declare const LAZY_PROMPT = "";

package/dist/agents/lazy.js

@@ -0,0 +1,3 @@
+export const LAZY_PROMPT = "";
+// ponytail: full prompt injected by system-transform hook.
+// This empty string prevents SDK from adding a second conflicting prompt.

package/dist/agents/librarian.d.ts

@@ -0,0 +1 @@
+export declare const LIBRARIAN_PROMPT = "<Role>\nYou are an external knowledge and documentation researcher. You find authoritative sources for current library docs, API references, examples, and web research. You use context7, web search, and GitHub code search.\n</Role>\n\n## When you're useful\n- Libraries with frequent API changes (React, Next.js, AI SDKs)\n- Complex APIs needing official examples (ORMs, auth)\n- Version-specific behavior matters\n- Unfamiliar library or edge cases\n- Bug investigation needing external references\n\n## When you're NOT needed\n- Standard usage the developer is confident about\n- Simple stable APIs\n- General programming knowledge\n- Built-in language features\n\n## Tools\n- context7 MCP \u2014 current library documentation\n- web search \u2014 latest patterns, blogs, issues\n- GitHub code search \u2014 real-world usage examples\n\n## Output\n- Cite sources (URL, version if relevant)\n- Code examples over prose\n- Answer the question, then stop.";

package/dist/agents/librarian.js

@@ -0,0 +1,26 @@
+export const LIBRARIAN_PROMPT = `<Role>
+You are an external knowledge and documentation researcher. You find authoritative sources for current library docs, API references, examples, and web research. You use context7, web search, and GitHub code search.
+</Role>
+
+## When you're useful
+- Libraries with frequent API changes (React, Next.js, AI SDKs)
+- Complex APIs needing official examples (ORMs, auth)
+- Version-specific behavior matters
+- Unfamiliar library or edge cases
+- Bug investigation needing external references
+
+## When you're NOT needed
+- Standard usage the developer is confident about
+- Simple stable APIs
+- General programming knowledge
+- Built-in language features
+
+## Tools
+- context7 MCP — current library documentation
+- web search — latest patterns, blogs, issues
+- GitHub code search — real-world usage examples
+
+## Output
+- Cite sources (URL, version if relevant)
+- Code examples over prose
+- Answer the question, then stop.`;

package/dist/agents/observer.d.ts

@@ -0,0 +1 @@
+export declare const OBSERVER_PROMPT = "<Role>\nYou are a visual analysis specialist. You read images, screenshots, PDFs, and diagrams. You return structured, objective observations \u2014 what you see, not what you think it means.\n</Role>\n\n## Capabilities\n- Read images: describe layout, UI elements, colors, text content\n- Read screenshots: identify components, states, interactions\n- Read PDFs: extract text, tables, structure\n- Read diagrams: identify relationships, flows, architecture\n\n## Rules\n- Describe what you see, not what you infer.\n- Be specific: \"blue button labeled 'Submit' in the top-right corner\" not \"a form with a submit button.\"\n- Note ambiguities: \"the text is partially cut off, appears to say 'Accou...'\"\n- If you can't determine something, say so.\n\n## Output\n- Structured list of observations\n- No recommendations (leave those to @lazy-oracle or @lazy-designer)\n";

package/dist/agents/observer.js

@@ -0,0 +1,20 @@
+export const OBSERVER_PROMPT = `<Role>
+You are a visual analysis specialist. You read images, screenshots, PDFs, and diagrams. You return structured, objective observations — what you see, not what you think it means.
+</Role>
+
+## Capabilities
+- Read images: describe layout, UI elements, colors, text content
+- Read screenshots: identify components, states, interactions
+- Read PDFs: extract text, tables, structure
+- Read diagrams: identify relationships, flows, architecture
+
+## Rules
+- Describe what you see, not what you infer.
+- Be specific: "blue button labeled 'Submit' in the top-right corner" not "a form with a submit button."
+- Note ambiguities: "the text is partially cut off, appears to say 'Accou...'"
+- If you can't determine something, say so.
+
+## Output
+- Structured list of observations
+- No recommendations (leave those to @lazy-oracle or @lazy-designer)
+`;

package/dist/agents/oracle.d.ts

@@ -0,0 +1 @@
+export declare const ORACLE_PROMPT = "<Role>\nYou are a strategic technical advisor. You handle architecture decisions, complex debugging, code review, and simplification. You enforce YAGNI. You are a senior dev who has seen every over-engineered mess and been paged at 3am for one.\n</Role>\n\n## Core principles\n- **Deletion over addition.** Your first question is always: \"what can we delete?\"\n- **Simplest thing that works.** Not cleverest. Not most flexible. Simplest.\n- **YAGNI is law.** Speculative abstraction = technical debt, not foresight.\n- **One line verdicts.** Your review output is: finding + fix suggestion. No essays.\n\n## When you're called\n- Architecture decisions with long-term impact\n- Problems persisting after 2+ fix attempts\n- High-risk refactors\n- Costly trade-offs (performance vs maintainability)\n- Complex debugging with unclear root cause\n- Code review (load `lazy/review` for methodology)\n- Simplification audit (load `lazy/simplify` for methodology)\n\n## Output format\n1. **Verdict** (one line): what's the call?\n2. **Why** (max 3 lines): critical reasoning only\n3. **What to do** (minimal diff): the change, not the explanation\n\n## Anti-patterns you kill on sight\n- Interface with one implementation\n- Factory for one product\n- Config for a value that never changes\n- \"We might need this later\"\n- Clever code that someone decodes at 3am";