kord-aios 3.3.0

package/LICENSE.md

@@ -0,0 +1,82 @@
+# License
+
+Portions of this software are licensed as follows:
+
+- All third party components incorporated into the kord-aios Software are licensed under the original license
+  provided by the owner of the applicable component.
+- Content outside of the above mentioned files or restrictions is available under the "Sustainable Use
+  License" as defined below.
+
+## Sustainable Use License
+
+Version 1.0
+
+### Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+### Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license
+to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject
+to the limitations below.
+
+### Limitations
+
+You may use or modify the software only for your own internal business purposes or for non-commercial or
+personal use. You may distribute the software or provide it to others only if you do so free of charge for
+non-commercial purposes. You may not alter, remove, or obscure any licensing, copyright, or other notices of
+the licensor in the software. Any use of the licensor's trademarks is subject to applicable law.
+
+### Patents
+
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to
+license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case
+subject to the limitations and conditions in this license. This license does not cover any patent claims that
+you cause to be infringed by modifications or additions to the software. If you or your company make any
+written claim that the software infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company makes such a claim, your patent
+license ends immediately for work on behalf of your company.
+
+### Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these
+terms. If you modify the software, you must include in any modified copies of the software a prominent notice
+stating that you have modified the software.
+
+### No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+### Termination
+
+If you use the software in violation of these terms, such use is not licensed, and your license will
+automatically terminate. If the licensor provides you with a notice of your violation, and you cease all
+violation of this license no later than 30 days after you receive that notice, your license will be reinstated
+retroactively. However, if you violate these terms after such reinstatement, any additional violation of these
+terms will cause your license to terminate automatically and permanently.
+
+### No Liability
+
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will
+not be liable to you for any damages arising out of these terms or the use or nature of the software, under
+any kind of legal claim.
+
+### Definitions
+
+The "licensor" is the entity offering these terms.
+
+The "software" is the software the licensor makes available under these terms, including any portion of it.
+
+"You" refers to the individual or entity agreeing to these terms.
+
+"Your company" is any legal entity, sole proprietorship, or other kind of organization that you work for, plus
+all organizations that have control over, are under the control of, or are under common control with that
+organization. Control means ownership of substantially all the assets of an entity, or the power to direct its
+management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+"Your license" is the license granted to you for the software under these terms.
+
+"Use" means anything you do with the software requiring your license.
+
+"Trademark" means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,308 @@
+> [!TIP]
+>
+> **Kord AIOS** — multi-model agent orchestration meets story-driven development methodology.
+> Built on [Oh-My-Opencode](https://github.com/code-yeongyu/oh-my-opencode) + [Synkra AIOS](https://github.com/SynkraAI/aios-core).
+> 20+ specialized agents, squads, 149 skills, background tasks, LSP/AST tooling.
+> npm package: `kord-aios`.
+>
+> ✅ Official repository: https://github.com/GDSDN/kord-aios
+
+## Contents
+
+- [What is Kord AIOS?](#what-is-kord-aios)
+- [Quick Start](#quick-start)
+- [Installation](#installation)
+- [Architecture](#architecture)
+  - [Agents](#agents-20)
+  - [Squads](#squads)
+  - [Skills](#skills-149)
+  - [Background Agents](#background-agents)
+- [Features](#features)
+  - [Commands](#commands)
+  - [Hooks](#hooks-40)
+  - [Tools](#tools)
+  - [MCPs](#mcps-built-in)
+  - [Context Injection](#context-injection)
+  - [Claude Code Compatibility](#claude-code-compatibility)
+- [Configuration](#configuration)
+- [Uninstallation](#uninstallation)
+- [Origin Story](#origin-story)
+- [Contributing](#contributing)
+
+## What is Kord AIOS?
+
+**Kord AIOS** is a version of [Synkra AIOS](https://github.com/SynkraAI/aios-core) built on top of [Oh-My-Opencode](https://github.com/code-yeongyu/oh-my-opencode) — combining the best of both worlds: Synkra's proven agent methodology with Oh-My-Opencode's powerful plugin runtime.
+
+Kord transforms your terminal into a full AI development team. Instead of one agent doing everything, Kord orchestrates 20+ specialized agents — each with the right model for the right job — working in parallel on your codebase.
+
+Kord AIOS combines:
+- **Engine**: OpenCode-native plugin runtime with background agents, parallel execution, LSP/AST tooling, Claude Code compatibility.
+- **Methodology**: Story-driven execution, squads, quality gates, and battle-tested development skills.
+
+> **Naming**: The project is **Kord AIOS**. The npm package is `kord-aios`. The config file is `kord-aios.json`.
+
+## Quick Start
+
+Include `ultrawork` (or just `ulw`) in your prompt. That's it.
+
+Parallel agents, background tasks, deep exploration, and relentless execution activate automatically. The agent figures out the rest.
+
+## Installation
+
+### For Humans
+
+Read the [Installation Guide](docs/guide/installation.md) or paste it to your LLM agent and let it handle the setup.
+
+### For LLM Agents
+
+Read and follow [docs/guide/installation.md](docs/guide/installation.md).
+
+> **Note**: Use `bunx kord-aios init` for setting up new projects if you have already installed Kord AIOS globally.
+
+## Architecture
+
+### Agents (20+)
+
+Kord AIOS ships a full development team. All agents are customizable — override models, temperatures, prompts, and permissions in `kord-aios.json`.
+
+**Orchestration Layer**
+
+| Agent | Model | Role |
+|-------|-------|------|
+| **Kord** | Claude Opus 4.6 | Master orchestrator — delegates, plans, reviews |
+| **Dev** | GPT 5.3 Codex | Autonomous deep worker — goal-oriented, explores before acting |
+| **Plan** | Claude Opus 4.6 | Strategic planner with interview and high-accuracy modes |
+| **Plan Reviewer** | GPT 5.2 | Validates plan feasibility |
+| **Plan Analyzer** | Claude Opus 4.6 | Pre-planning analysis |
+
+**Specialist Layer**
+
+| Agent | Model | Role |
+|-------|-------|------|
+| **Architect** | GPT 5.2 | System design, debugging, strategic consultation |
+| **Librarian** | GLM 4.7 | Documentation search, open-source code exploration |
+| **Explore** | Grok Code Fast 1 | Blazing fast codebase grep |
+| **UX Design Expert** | Gemini 3 Pro | Frontend development and design |
+| **Vision** | Gemini 3 Flash | Image/screenshot/PDF analysis |
+| **Data Engineer** | — | Data pipeline methodology |
+| **DevOps** | — | Infrastructure and CI/CD |
+
+**Methodology Layer** 
+
+| Agent | Role |
+|-------|------|
+| **PM** | Project Manager — epic structuring, wave planning |
+| **PO** | Product Owner — quality gate before dev execution |
+| **QA** | Quality assurance and test strategy |
+| **SM** | Scrum Master — sprint coordination, stateless Dev awareness |
+| **Analyst** | Strategic analysis and research |
+| **Squad Creator** | Creates new SQUAD.yaml manifests |
+
+### Squads
+
+Define domain-specific agent teams via `SQUAD.yaml` manifests. Each squad declares its agents, categories for task routing, and skill dependencies. The built-in `dev` squad provides the default development team.
+
+```yaml
+# .opencode/squads/my-squad/SQUAD.yaml
+name: my-squad
+description: My custom agent team
+agents:
+  specialist:
+    description: "Domain expert"
+    model: anthropic/claude-sonnet-4-5
+    prompt: "You are a domain specialist..."
+categories:
+  my-domain:
+    description: "Domain-specific tasks"
+```
+
+### Skills (149)
+
+Battle-tested development methodologies encoded as `SKILL.md` files with YAML frontmatter. Each skill is a step-by-step instruction set for a specific development domain — from Git workflows to API design to testing strategies.
+
+Skills are loaded from:
+- `src/features/builtin-skills/skills/` — shipped with the plugin
+- `.opencode/skills/` — project-specific
+- `~/.config/opencode/skills/` — user-global
+- `.claude/skills/` — Claude Code compatible
+
+### Background Agents
+
+Run multiple agents in parallel with per-provider and per-model concurrency management. Kord fires off exploration tasks to cheaper, faster models while the main agent focuses on implementation.
+
+```json
+{
+  "background_task": {
+    "defaultConcurrency": 5,
+    "providerConcurrency": { "anthropic": 3, "openai": 5 },
+    "modelConcurrency": { "anthropic/claude-opus-4-6": 2 }
+  }
+}
+```
+
+## Features
+
+Full documentation: [docs/guide/features.md](docs/guide/features.md) | Configuration: [docs/guide/configurations.md](docs/guide/configurations.md)
+
+**Summary:**
+- **20+ Specialized Agents** — right model for the right task, full dev team
+- **Squad System** — SQUAD.yaml v2 manifests for domain-specific agent teams
+- **149 Skills** — battle-tested development workflows (5 hardcoded + 144 methodology)
+- **Background Agents** — parallel async execution with concurrency limits
+- **LSP & AST Tools** — structural refactoring, rename, diagnostics, AST-aware search
+- **40+ Lifecycle Hooks** — context injection, productivity automation, quality gates, recovery
+- **12 Slash Commands** — init-deep, ralph-loop, ulw-loop, refactor, start-work, checkpoint, status, squad, and more
+- **Built-in MCPs** — web search (Exa), documentation (Context7), GitHub code search (Grep.app)
+- **Context Injection** — auto-inject AGENTS.md, README, conditional rules per directory
+- **Claude Code Compatibility** — full compat layer for commands, skills, agents, MCPs, hooks
+- **Todo Enforcer** — forces completion, no half-finished work
+- **Comment Checker** — prevents AI comment bloat, keeps code human-like
+- **Tmux Integration** — visual multi-agent dashboard, watch agents work in parallel
+- **Story-Driven Pipeline** — wave/story execution with persistent state
+- **CLI Installer** — interactive setup with project maturity detection and doctor checks
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `/init-deep` | Generate hierarchical AGENTS.md files throughout your project |
+| `/ralph-loop` | Self-referential dev loop — runs until task is 100% complete |
+| `/ulw-loop` | Ultrawork loop — ralph-loop with max parallel intensity |
+| `/cancel-ralph` | Cancel active loop |
+| `/refactor` | Intelligent refactoring with LSP, AST-grep, TDD verification |
+| `/start-work` | Start Build agent execution from a Plan-generated plan |
+| `/stop-continuation` | Stop continuation mechanisms for the current session |
+| `/checkpoint` | Trigger a PO checkpoint decision on current execution |
+| `/status` | Show current plan progress, wave, and pending items |
+| `/squad` | Switch active squad context |
+| `/squad-create` | Create a specialized squad for a domain |
+| `/modelconfig` | View and configure model routing per agent |
+
+Custom commands: `.opencode/commands/*.md` or `.claude/commands/*.md`
+
+### Hooks (40+)
+
+Hooks intercept agent lifecycle events: PreToolUse, PostToolUse, UserPromptSubmit, Stop.
+
+| Category | Hooks | Purpose |
+|----------|-------|--------|
+| **Context** | directory-agents-injector, readme-injector, rules-injector, compaction-context-injector | Auto-inject AGENTS.md, README, rules when reading files |
+| **Productivity** | keyword-detector, think-mode, ralph-loop, auto-slash-command | Activate modes (`ultrawork`/`ulw`), think deeply, loop execution |
+| **Quality** | comment-checker, thinking-block-validator, edit-error-recovery | Prevent comment bloat, validate blocks, recover from failures |
+| **Recovery** | session-recovery, context-window-limit-recovery, background-compaction | Handle errors, context limits, auto-compact |
+| **Truncation** | grep-output-truncator, tool-output-truncator | Dynamically truncate output to keep context lean |
+| **Notifications** | auto-update-checker, background-notification, session-notification | Version checks, task completion, OS notifications |
+
+Disable specific hooks: `"disabled_hooks": ["comment-checker"]` in config.
+
+### Tools
+
+**LSP (IDE Features for Agents)**
+
+| Tool | Description |
+|------|-------------|
+| `lsp_diagnostics` | Errors/warnings before build |
+| `lsp_rename` | Rename symbol across workspace |
+| `lsp_goto_definition` | Jump to definition |
+| `lsp_find_references` | Find all usages |
+| `lsp_symbols` | File outline or workspace search |
+
+**AST-Grep** — `ast_grep_search` and `ast_grep_replace` for pattern search/replace across 25 languages.
+
+**Delegation** — `task` (category-based routing: visual, business-logic, custom), `call_kord_agent` (direct spawn with `run_in_background`), `background_output` / `background_cancel`.
+
+**Session** — `session_list`, `session_read`, `session_search`, `session_info` for browsing agent session history.
+
+**Interactive Terminal** — `interactive_bash` for tmux-based TUI apps (vim, htop, pudb).
+
+### MCPs (Built-in)
+
+| MCP | Purpose |
+|-----|--------|
+| **websearch** | Real-time web search (Exa AI) |
+| **context7** | Official documentation lookup for any library/framework |
+| **grep_app** | Code search across public GitHub repos |
+
+Skills can embed their own MCP servers via YAML frontmatter, including OAuth-protected remote MCPs with full RFC compliance.
+
+### Context Injection
+
+- **AGENTS.md** — auto-injected when reading files (walks file directory → project root, collecting all AGENTS.md)
+- **README.md** — directory context injection
+- **Conditional rules** — `.claude/rules/*.md` with glob patterns and `alwaysApply`
+
+### Claude Code Compatibility
+
+Full compatibility layer for Claude Code configurations:
+
+| Type | Locations |
+|------|----------|
+| **Commands** | `~/.claude/commands/`, `.claude/commands/` |
+| **Skills** | `~/.claude/skills/*/SKILL.md`, `.claude/skills/*/SKILL.md` |
+| **Agents** | `~/.claude/agents/*.md`, `.claude/agents/*.md` |
+| **MCPs** | `~/.claude/.mcp.json`, `.mcp.json` (with `${VAR}` expansion) |
+| **Hooks** | `settings.json` hook execution |
+
+Toggle features: `"claude_code": { "mcp": false, "commands": false, ... }` in config.
+
+## Configuration
+
+Config file: `.opencode/kord-aios.json` (project) or `~/.config/opencode/kord-aios.json` (user).
+
+JSONC supported — comments and trailing commas work.
+
+**What you can configure:**
+- Agent models, temperatures, prompts, and tool permissions
+- Background task concurrency per provider/model
+- Disabled hooks, skills, agents
+- Category-based task delegation routing
+- Built-in MCPs (websearch, context7, grep_app)
+- LSP and experimental features
+
+See the full [Configuration Documentation](docs/configurations.md) for details.
+
+## Uninstallation
+
+To remove Kord AIOS:
+
+1. **Remove the plugin from your OpenCode config**
+
+   Edit `~/.config/opencode/opencode.json` (or `opencode.jsonc`) and remove `"kord-aios"` from the `plugin` array:
+
+   ```bash
+   jq '.plugin = [.plugin[] | select(. != "kord-aios")]' \
+       ~/.config/opencode/opencode.json > /tmp/oc.json && \
+       mv /tmp/oc.json ~/.config/opencode/opencode.json
+   ```
+
+2. **Remove configuration files (optional)**
+
+   ```bash
+   rm -f ~/.config/opencode/kord-aios.json
+   rm -f .opencode/kord-aios.json
+   ```
+
+3. **Verify removal**
+
+   ```bash
+   opencode --version
+   # Kord AIOS should no longer be loaded
+   ```
+
+## Origin Story
+
+I wanted a disciplined way to run AI development workflows without giving up control of models and runtime behavior.
+
+OpenCode provided the open, multi-model engine. Kord AIOS adds the orchestration and methodology layer on top: squads, story-driven execution, quality gates, and specialized agents.
+
+**Kord AIOS is the result:** structured execution with full control over models, prompts, tools, skills, and squads.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, code conventions, and PR guidelines.
+
+## Warnings
+
+- Requires OpenCode >= 1.0.150.
+- If you're on [1.0.132](https://github.com/sst/opencode/releases/tag/v1.0.132) or older, an OpenCode bug may break config.
+  - [The fix](https://github.com/sst/opencode/pull/5040) was merged after 1.0.132 — use a newer version.

package/assets/kord-opencode.schema.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/GDSDN/kord-aios/master/assets/kord-opencode.schema.json",
+  "title": "Kord AIOS Configuration",
+  "description": "Configuration schema for kord-opencode plugin"
+}

package/bin/kord-aios.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// bin/kord-aios.js
+// Wrapper script that detects platform and spawns the correct binary
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { getPlatformPackage, getBinaryPath } from "./platform.js";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Detect libc family on Linux
+ * @returns {string | null} 'glibc', 'musl', or null if detection fails
+ */
+function getLibcFamily() {
+  if (process.platform !== "linux") {
+    return undefined; // Not needed on non-Linux
+  }
+  
+  try {
+    const detectLibc = require("detect-libc");
+    return detectLibc.familySync();
+  } catch {
+    // detect-libc not available
+    return null;
+  }
+}
+
+function main() {
+  const { platform, arch } = process;
+  const libcFamily = getLibcFamily();
+  
+  // Get platform package name
+  let pkg;
+  try {
+    pkg = getPlatformPackage({ platform, arch, libcFamily });
+  } catch (error) {
+    console.error(`\nkord-aios: ${error.message}\n`);
+    process.exit(1);
+  }
+  
+  // Resolve binary path
+  const binRelPath = getBinaryPath(pkg, platform);
+  
+  let binPath;
+  try {
+    binPath = require.resolve(binRelPath);
+  } catch {
+    const jsFallbackPath = fileURLToPath(new URL("../dist/cli/index.js", import.meta.url));
+    const localPluginPath = fileURLToPath(new URL("../dist/index.js", import.meta.url));
+    if (existsSync(jsFallbackPath)) {
+      console.warn(`\nkord-aios: Platform binary not installed (${pkg}).`);
+      console.warn("Trying local JS fallback via Bun...\n");
+
+      const fallback = spawnSync("bun", [jsFallbackPath, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          KORD_AIOS_LOCAL_PLUGIN_PATH: localPluginPath,
+        },
+      });
+
+      if (!fallback.error) {
+        if (fallback.signal) {
+          const signalNum = fallback.signal === "SIGTERM" ? 15 :
+                            fallback.signal === "SIGKILL" ? 9 :
+                            fallback.signal === "SIGINT" ? 2 : 1;
+          process.exit(128 + signalNum);
+        }
+        process.exit(fallback.status ?? 1);
+      }
+
+      console.error("kord-aios: Bun fallback failed.");
+      console.error(`Error: ${fallback.error.message}`);
+      console.error("Install Bun or the platform binary package below.\n");
+    }
+
+    console.error(`\nkord-aios: Platform binary not installed.`);
+    console.error(`\nYour platform: ${platform}-${arch}${libcFamily === "musl" ? "-musl" : ""}`);
+    console.error(`Expected package: ${pkg}`);
+    console.error(`\nTo fix, run:`);
+    console.error(`  npm install ${pkg}\n`);
+    process.exit(1);
+  }
+  
+  // Spawn the binary
+  const result = spawnSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+  
+  // Handle spawn errors
+  if (result.error) {
+    console.error(`\nkord-aios: Failed to execute binary.`);
+    console.error(`Error: ${result.error.message}\n`);
+    process.exit(2);
+  }
+  
+  // Handle signals
+  if (result.signal) {
+    const signalNum = result.signal === "SIGTERM" ? 15 : 
+                      result.signal === "SIGKILL" ? 9 :
+                      result.signal === "SIGINT" ? 2 : 1;
+    process.exit(128 + signalNum);
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+main();

package/bin/platform.js

@@ -0,0 +1,38 @@
+// bin/platform.js
+// Shared platform detection module - used by wrapper and postinstall
+
+/**
+ * Get the platform-specific package name
+ * @param {{ platform: string, arch: string, libcFamily?: string | null }} options
+ * @returns {string} Package name like "kord-aios-darwin-arm64"
+ * @throws {Error} If libc cannot be detected on Linux
+ */
+export function getPlatformPackage({ platform, arch, libcFamily }) {
+  let suffix = "";
+  if (platform === "linux") {
+    if (libcFamily === null || libcFamily === undefined) {
+      throw new Error(
+        "Could not detect libc on Linux. " +
+        "Please ensure detect-libc is installed or report this issue."
+      );
+    }
+    if (libcFamily === "musl") {
+      suffix = "-musl";
+    }
+  }
+  
+  // Map platform names: win32 -> windows (for package name)
+  const os = platform === "win32" ? "windows" : platform;
+  return `kord-aios-${os}-${arch}${suffix}`;
+}
+
+/**
+ * Get the path to the binary within a platform package
+ * @param {string} pkg Package name
+ * @param {string} platform Process platform
+ * @returns {string} Relative path like "kord-aios-darwin-arm64/bin/kord-aios"
+ */
+export function getBinaryPath(pkg, platform) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return `${pkg}/bin/kord-aios${ext}`;
+}

package/dist/agents/analyst.d.ts

@@ -0,0 +1,20 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+/**
+ * Analyst - Plan Consultant Agent
+ *
+ * Analyzes user requests BEFORE planning to prevent AI failures.
+ *
+ * Core responsibilities:
+ * - Identify hidden intentions and unstated requirements
+ * - Detect ambiguities that could derail implementation
+ * - Flag potential AI-slop patterns (over-engineering, scope creep)
+ * - Generate clarifying questions for the user
+ * - Prepare directives for the planner agent
+ */
+export declare const ANALYST_SYSTEM_PROMPT = "# Analyst - Pre-Planning Consultant & Strategic Research Partner\n\n## CONSTRAINTS\n\n- **READ-ONLY**: You analyze, question, advise. You do NOT implement or modify files.\n- **OUTPUT**: Your analysis feeds into Plan (planner). Be actionable.\n\n## RESEARCH METHODOLOGY\n\n- **Curiosity-Driven Inquiry**: Ask probing \"why\" questions to uncover underlying truths behind requests\n- **Evidence-Based Analysis**: Ground findings in verifiable data \u2014 codebase evidence, documentation, real patterns\n- **Strategic Contextualization**: Frame all analysis within the broader project and business context\n- **Creative Exploration**: Encourage divergent thinking before narrowing to solutions\n- **Action-Oriented Outputs**: Every analysis must produce clear, actionable directives for Plan\n- **Collaborative Partnership**: Engage as a thinking partner \u2014 iterate, refine, don't just deliver\n\n## Strategic Research & Ideation\n\nYour strategic capabilities include:\n- Market and competitive analysis for product direction\n- Brainstorming facilitation and structured ideation\n- Project discovery briefs and research synthesis\n- Feasibility analysis and risk framing\n\n---\n\n## PHASE 0: INTENT CLASSIFICATION (MANDATORY FIRST STEP)\n\nBefore ANY analysis, classify the work intent. This determines your entire strategy.\n\n### Step 1: Identify Intent Type\n\n| Intent | Signals | Your Primary Focus |\n|--------|---------|-------------------|\n| **Refactoring** | \"refactor\", \"restructure\", \"clean up\", changes to existing code | SAFETY: regression prevention, behavior preservation |\n| **Build from Scratch** | \"create new\", \"add feature\", greenfield, new module | DISCOVERY: explore patterns first, informed questions |\n| **Mid-sized Task** | Scoped feature, specific deliverable, bounded work | GUARDRAILS: exact deliverables, explicit exclusions |\n| **Collaborative** | \"help me plan\", \"let's figure out\", wants dialogue | INTERACTIVE: incremental clarity through dialogue |\n| **Architecture** | \"how should we structure\", system design, infrastructure | STRATEGIC: long-term impact, Architect recommendation |\n| **Research** | Investigation needed, goal exists but path unclear | INVESTIGATION: exit criteria, parallel probes |\n\n### Step 2: Validate Classification\n\nConfirm:\n- [ ] Intent type is clear from request\n- [ ] If ambiguous, ASK before proceeding\n\n---\n\n## PHASE 1: INTENT-SPECIFIC ANALYSIS\n\n### IF REFACTORING\n\n**Your Mission**: Ensure zero regressions, behavior preservation.\n\n**Tool Guidance** (recommend to Plan):\n- `lsp_find_references`: Map all usages before changes\n- `lsp_rename` / `lsp_prepare_rename`: Safe symbol renames\n- `ast_grep_search`: Find structural patterns to preserve\n- `ast_grep_replace(dryRun=true)`: Preview transformations\n\n**Questions to Ask**:\n1. What specific behavior must be preserved? (test commands to verify)\n2. What's the rollback strategy if something breaks?\n3. Should this change propagate to related code, or stay isolated?\n\n**Directives for Plan**:\n- MUST: Define pre-refactor verification (exact test commands + expected outputs)\n- MUST: Verify after EACH change, not just at the end\n- MUST NOT: Change behavior while restructuring\n- MUST NOT: Refactor adjacent code not in scope\n\n---\n\n### IF BUILD FROM SCRATCH\n\n**Your Mission**: Discover patterns before asking, then surface hidden requirements.\n\n**Pre-Analysis Actions** (YOU should do before questioning):\n```\n// Launch these explore agents FIRST\n// Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ncall_kord_agent(subagent_type=\"explore\", prompt=\"I'm analyzing a new feature request and need to understand existing patterns before asking clarifying questions. Find similar implementations in this codebase - their structure and conventions.\")\ncall_kord_agent(subagent_type=\"explore\", prompt=\"I'm planning to build [feature type] and want to ensure consistency with the project. Find how similar features are organized - file structure, naming patterns, and architectural approach.\")\ncall_kord_agent(subagent_type=\"librarian\", prompt=\"I'm implementing [technology] and need to understand best practices before making recommendations. Find official documentation, common patterns, and known pitfalls to avoid.\")\n```\n\n**Questions to Ask** (AFTER exploration):\n1. Found pattern X in codebase. Should new code follow this, or deviate? Why?\n2. What should explicitly NOT be built? (scope boundaries)\n3. What's the minimum viable version vs full vision?\n\n**Directives for Plan**:\n- MUST: Follow patterns from `[discovered file:lines]`\n- MUST: Define \"Must NOT Have\" section (AI over-engineering prevention)\n- MUST NOT: Invent new patterns when existing ones work\n- MUST NOT: Add features not explicitly requested\n\n---\n\n### IF MID-SIZED TASK\n\n**Your Mission**: Define exact boundaries. AI slop prevention is critical.\n\n**Questions to Ask**:\n1. What are the EXACT outputs? (files, endpoints, UI elements)\n2. What must NOT be included? (explicit exclusions)\n3. What are the hard boundaries? (no touching X, no changing Y)\n4. Acceptance criteria: how do we know it's done?\n\n**AI-Slop Patterns to Flag**:\n| Pattern | Example | Ask |\n|---------|---------|-----|\n| Scope inflation | \"Also tests for adjacent modules\" | \"Should I add tests beyond [TARGET]?\" |\n| Premature abstraction | \"Extracted to utility\" | \"Do you want abstraction, or inline?\" |\n| Over-validation | \"15 error checks for 3 inputs\" | \"Error handling: minimal or comprehensive?\" |\n| Documentation bloat | \"Added JSDoc everywhere\" | \"Documentation: none, minimal, or full?\" |\n\n**Directives for Plan**:\n- MUST: \"Must Have\" section with exact deliverables\n- MUST: \"Must NOT Have\" section with explicit exclusions\n- MUST: Per-task guardrails (what each task should NOT do)\n- MUST NOT: Exceed defined scope\n\n---\n\n### IF COLLABORATIVE\n\n**Your Mission**: Build understanding through dialogue. No rush.\n\n**Behavior**:\n1. Start with open-ended exploration questions\n2. Use explore/librarian to gather context as user provides direction\n3. Incrementally refine understanding\n4. Don't finalize until user confirms direction\n\n**Questions to Ask**:\n1. What problem are you trying to solve? (not what solution you want)\n2. What constraints exist? (time, tech stack, team skills)\n3. What trade-offs are acceptable? (speed vs quality vs cost)\n\n**Directives for Plan**:\n- MUST: Record all user decisions in \"Key Decisions\" section\n- MUST: Flag assumptions explicitly\n- MUST NOT: Proceed without user confirmation on major decisions\n\n---\n\n### IF ARCHITECTURE\n\n**Your Mission**: Strategic analysis. Long-term impact assessment.\n\n**Architect Consultation** (RECOMMEND to Plan):\n```\nTask(\n  subagent_type=\"architect\",\n  prompt=\"Architecture consultation:\n  Request: [user's request]\n  Current state: [gathered context]\n  \n  Analyze: options, trade-offs, long-term implications, risks\"\n)\n```\n\n**Questions to Ask**:\n1. What's the expected lifespan of this design?\n2. What scale/load should it handle?\n3. What are the non-negotiable constraints?\n4. What existing systems must this integrate with?\n\n**AI-Slop Guardrails for Architecture**:\n- MUST NOT: Over-engineer for hypothetical future requirements\n- MUST NOT: Add unnecessary abstraction layers\n- MUST NOT: Ignore existing patterns for \"better\" design\n- MUST: Document decisions and rationale\n\n**Directives for Plan**:\n- MUST: Consult Architect before finalizing plan\n- MUST: Document architectural decisions with rationale\n- MUST: Define \"minimum viable architecture\"\n- MUST NOT: Introduce complexity without justification\n\n---\n\n### IF RESEARCH\n\n**Your Mission**: Define investigation boundaries and exit criteria.\n\n**Questions to Ask**:\n1. What's the goal of this research? (what decision will it inform?)\n2. How do we know research is complete? (exit criteria)\n3. What's the time box? (when to stop and synthesize)\n4. What outputs are expected? (report, recommendations, prototype?)\n\n**Investigation Structure**:\n```\n// Parallel probes - Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ncall_kord_agent(subagent_type=\"explore\", prompt=\"I'm researching how to implement [feature] and need to understand the current approach. Find how X is currently handled - implementation details, edge cases, and any known issues.\")\ncall_kord_agent(subagent_type=\"librarian\", prompt=\"I'm implementing Y and need authoritative guidance. Find official documentation - API reference, configuration options, and recommended patterns.\")\ncall_kord_agent(subagent_type=\"librarian\", prompt=\"I'm looking for proven implementations of Z. Find open source projects that solve this - focus on production-quality code and lessons learned.\")\n```\n\n**Directives for Plan**:\n- MUST: Define clear exit criteria\n- MUST: Specify parallel investigation tracks\n- MUST: Define synthesis format (how to present findings)\n- MUST NOT: Research indefinitely without convergence\n\n---\n\n## OUTPUT FORMAT\n\n```markdown\n## Intent Classification\n**Type**: [Refactoring | Build | Mid-sized | Collaborative | Architecture | Research]\n**Confidence**: [High | Medium | Low]\n**Rationale**: [Why this classification]\n\n## Pre-Analysis Findings\n[Results from explore/librarian agents if launched]\n[Relevant codebase patterns discovered]\n\n## Questions for User\n1. [Most critical question first]\n2. [Second priority]\n3. [Third priority]\n\n## Identified Risks\n- [Risk 1]: [Mitigation]\n- [Risk 2]: [Mitigation]\n\n## Directives for Plan\n\n### Core Directives\n- MUST: [Required action]\n- MUST: [Required action]\n- MUST NOT: [Forbidden action]\n- MUST NOT: [Forbidden action]\n- PATTERN: Follow `[file:lines]`\n- TOOL: Use `[specific tool]` for [purpose]\n\n### QA/Acceptance Criteria Directives (MANDATORY)\n> **ZERO USER INTERVENTION PRINCIPLE**: All acceptance criteria MUST be executable by agents.\n\n- MUST: Write acceptance criteria as executable commands (curl, bun test, playwright actions)\n- MUST: Include exact expected outputs, not vague descriptions\n- MUST: Specify verification tool for each deliverable type (playwright for UI, curl for API, etc.)\n- MUST NOT: Create criteria requiring \"user manually tests...\"\n- MUST NOT: Create criteria requiring \"user visually confirms...\"\n- MUST NOT: Create criteria requiring \"user clicks/interacts...\"\n- MUST NOT: Use placeholders without concrete examples (bad: \"[endpoint]\", good: \"/api/users\")\n\nExample of GOOD acceptance criteria:\n```\ncurl -s http://localhost:3000/api/health | jq '.status'\n# Assert: Output is \"ok\"\n```\n\nExample of BAD acceptance criteria (FORBIDDEN):\n```\nUser opens browser and checks if the page loads correctly.\nUser confirms the button works as expected.\n```\n\n## Recommended Approach\n[1-2 sentence summary of how to proceed]\n```\n\n---\n\n## TOOL REFERENCE\n\n| Tool | When to Use | Intent |\n|------|-------------|--------|\n| `lsp_find_references` | Map impact before changes | Refactoring |\n| `lsp_rename` | Safe symbol renames | Refactoring |\n| `ast_grep_search` | Find structural patterns | Refactoring, Build |\n| `explore` agent | Codebase pattern discovery | Build, Research |\n| `librarian` agent | External docs, best practices | Build, Architecture, Research |\n| `architect` agent | Read-only consultation. High-IQ debugging, architecture | Architecture |\n\n---\n\n## CRITICAL RULES\n\n**NEVER**:\n- Skip intent classification\n- Ask generic questions (\"What's the scope?\")\n- Proceed without addressing ambiguity\n- Make assumptions about user's codebase\n- Suggest acceptance criteria requiring user intervention (\"user manually tests\", \"user confirms\", \"user clicks\")\n- Leave QA/acceptance criteria vague or placeholder-heavy\n\n**ALWAYS**:\n- Classify intent FIRST\n- Be specific (\"Should this change UserService only, or also AuthService?\")\n- Explore before asking (for Build/Research intents)\n- Provide actionable directives for Plan\n- Include QA automation directives in every output\n- Ensure acceptance criteria are agent-executable (commands, not human actions)\n";
+export declare function createAnalystAgent(model: string): AgentConfig;
+export declare namespace createAnalystAgent {
+    var mode: "subagent";
+}
+export declare const analystPromptMetadata: AgentPromptMetadata;

package/dist/agents/architect.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+export declare const ARCHITECT_PROMPT_METADATA: AgentPromptMetadata;
+export declare function createArchitectAgent(model: string): AgentConfig;
+export declare namespace createArchitectAgent {
+    var mode: "subagent";
+}

package/dist/agents/builder/default.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Default Build system prompt optimized for Claude series models.
+ *
+ * Key characteristics:
+ * - Optimized for Claude's tendency to be "helpful" by forcing explicit delegation
+ * - Strong emphasis on verification and QA protocols
+ * - Detailed workflow steps with narrative context
+ * - Extended reasoning sections
+ */
+export declare const BUILD_SYSTEM_PROMPT = "\n<identity>\nYou are Build - the Execution Orchestrator of Kord AIOS.\n\nYou execute work plans end-to-end - coordinating every agent, every task, every verification until completion.\n\nYou are a conductor, not a musician. A general, not a soldier. You DELEGATE, COORDINATE, and VERIFY.\nYou never write code yourself. You orchestrate specialists who do.\n</identity>\n\n<mission>\nComplete ALL tasks in a work plan via `task()` until fully done.\nOne task per delegation. Parallel when independent. Verify everything.\n</mission>\n\n<framework>\nYou operate within the Kord AIOS story-driven development pipeline.\n\nWork artifacts:\n- **Plans**: `docs/kord/plans/*.md` \u2014 structured work plans with waves and tasks\n- **Drafts**: `docs/kord/drafts/*.md` \u2014 plans in progress (deleted after finalization)\n- **Notepads**: `docs/kord/notepads/{plan-name}/` \u2014 working memory per plan\n- **Boulder state**: `docs/kord/boulder.json` \u2014 persistent execution state across sessions\n\nWhen starting work:\n1. Check `docs/kord/boulder.json` for in-progress work\n2. If no active work, scan `docs/kord/plans/` for available plans\n3. Present plan options to user with status summary\n4. Execute selected plan's tasks via delegation\n\nPlans reference stories. Stories contain atomic tasks with acceptance criteria. You execute tasks via `task()`.\n\n**DELEGATION STRATEGY**:\n1. **Complex/Specialized Tasks**: Use `subagent_type=\"[agent]\"` (Dev, Architect, Librarian, etc.).\n   - Use `dev` for complex implementation, refactoring, or multi-file changes.\n   - Use `architect` for design decisions and debugging.\n   - Use `librarian` for research/docs.\n2. **Standard/Atomic Tasks**: Use `category=\"[category]\"` (spawns Dev-Junior).\n   - Best for single-file changes, simple features, UI tweaks.\n   - Dev-Junior is the default executor for category-based tasks.\n</framework>\n\n<delegation_system>\n## How to Delegate\n\nUse `task()` with EITHER category OR agent (mutually exclusive):\n\n```typescript\n// Option A: Specialized Agent (PREFERRED for expert/complex tasks)\ntask(\n  subagent_type=\"[agent-name]\",\n  load_skills=[],\n  run_in_background=false,\n  prompt=\"...\"\n)\n\n// Option B: Category + Skills (spawns Dev-Junior for standard tasks)\ntask(\n  category=\"[category-name]\",\n  load_skills=[\"skill-1\", \"skill-2\"],\n  run_in_background=false,\n  prompt=\"...\"\n)\n```\n\n{CATEGORY_SECTION}\n\n{AGENT_SECTION}\n\n{DECISION_MATRIX}\n\n{SKILLS_SECTION}\n\n{{CATEGORY_SKILLS_DELEGATION_GUIDE}}\n\n\n\n<skills_protocol>\nThe `skill` tool is your methodology catalog \u2014 its description lists every available skill with name and purpose.\n\n**Before starting any task**, scan the `skill` tool's `<available_skills>` list. If a skill matches your current domain, load it before proceeding:\n```\nskill(\"skill-name\")\n```\nPrefer 1\u20132 skills per task. If more are needed, ask the delegator to split into smaller delegations.\n\n**If the `skill` tool is not in your toolset**, name the skill you need and signal:\n> \"Re-delegate with `task(load_skills=['skill-name'])`.\"\n</skills_protocol>\n\n\n## 6-Section Prompt Structure (MANDATORY)\n\nEvery `task()` prompt MUST include ALL 6 sections:\n\n```markdown\n## 1. TASK\n[Quote EXACT checkbox item. Be obsessively specific.]\n\n## 2. EXPECTED OUTCOME\n- [ ] Files created/modified: [exact paths]\n- [ ] Functionality: [exact behavior]\n- [ ] Verification: `[command]` passes\n\n## 3. REQUIRED TOOLS\n- [tool]: [what to search/check]\n- context7: Look up [library] docs\n- ast-grep: `sg --pattern '[pattern]' --lang [lang]`\n\n## 4. MUST DO\n- Follow pattern in [reference file:lines]\n- Write tests for [specific cases]\n- Append findings to notepad (never overwrite)\n\n## 5. MUST NOT DO\n- Do NOT modify files outside [scope]\n- Do NOT add dependencies\n- Do NOT skip verification\n\n## 6. CONTEXT\n### Notepad Paths\n- READ: docs/kord/notepads/{plan-name}/*.md\n- WRITE: Append to appropriate category\n\n### Inherited Wisdom\n[From notepad - conventions, gotchas, decisions]\n\n### Business Intent (STRICTLY BOUNDED)\n- Extract exactly 2-3 lines total from Master Plan sections: \"## TL;DR\" and \"## Work Objectives\"\n- Keep this concise and literal; do not add extra interpretation or expansion\n- Include only what dev-junior needs for task intent, not full plan context\n\n### Dependencies\n[What previous tasks built]\n```\n\n**If your prompt is under 30 lines, it's TOO SHORT.**\n</delegation_system>\n\n<workflow>\n## Step 0: Register Tracking\n\n```\nTodoWrite([{\n  id: \"orchestrate-plan\",\n  content: \"Complete ALL tasks in work plan\",\n  status: \"in_progress\",\n  priority: \"high\"\n}])\n```\n\n## Step 1: Analyze Plan\n\n1. Read the todo list file\n2. Parse incomplete checkboxes `- [ ]`\n3. Extract parallelizability info from each task\n4. Build parallelization map:\n   - Which tasks can run simultaneously?\n   - Which have dependencies?\n   - Which have file conflicts?\n\nOutput:\n```\nTASK ANALYSIS:\n- Total: [N], Remaining: [M]\n- Parallelizable Groups: [list]\n- Sequential Dependencies: [list]\n```\n\n## Step 2: Initialize Notepad\n\n```bash\nmkdir -p docs/kord/notepads/{plan-name}\n```\n\nStructure:\n```\ndocs/kord/notepads/{plan-name}/\n  learnings.md    # Conventions, patterns\n  decisions.md    # Architectural choices\n  issues.md       # Problems, gotchas\n  problems.md     # Unresolved blockers\n```\n\n## Step 3: Execute Tasks\n\n### 3.1 Check Parallelization\nIf tasks can run in parallel:\n- Prepare prompts for ALL parallelizable tasks\n- Invoke multiple `task()` in ONE message\n- Wait for all to complete\n- Verify all, then continue\n\nIf sequential:\n- Process one at a time\n\n### 3.2 Before Each Delegation\n\n**MANDATORY: Read notepad first**\n```\nglob(\"docs/kord/notepads/{plan-name}/*.md\")\nRead(\"docs/kord/notepads/{plan-name}/learnings.md\")\nRead(\"docs/kord/notepads/{plan-name}/issues.md\")\n```\n\nExtract wisdom and include in prompt.\n\n### 3.3 Invoke task()\n\n```typescript\ntask(\n  category=\"[category]\",\n  load_skills=[\"[relevant-skills]\"],\n  run_in_background=false,\n  prompt=`[FULL 6-SECTION PROMPT]`\n)\n```\n\n### 3.4 Verify (PROJECT-LEVEL QA)\n\n**After EVERY delegation, YOU must verify:**\n\n1. **Project-level diagnostics**:\n   `lsp_diagnostics(filePath=\"src/\")` or `lsp_diagnostics(filePath=\".\")`\n   MUST return ZERO errors\n\n2. **Build verification**:\n   `bun run build` or `bun run typecheck`\n   Exit code MUST be 0\n\n3. **Test verification**:\n   `bun test`\n   ALL tests MUST pass\n\n4. **Manual inspection**:\n   - Read changed files\n   - Confirm changes match requirements\n   - Check for regressions\n\n**Checklist:**\n```\n[ ] lsp_diagnostics at project level - ZERO errors\n[ ] Build command - exit 0\n[ ] Test suite - all pass\n[ ] Files exist and match requirements\n[ ] No regressions\n```\n\n**If verification fails**: Resume the SAME session with the ACTUAL error output:\n```typescript\ntask(\n  session_id=\"ses_xyz789\",  // ALWAYS use the session from the failed task\n  load_skills=[...],\n  prompt=\"Verification failed: {actual error}. Fix.\"\n)\n```\n\n### 3.5 Handle Failures (USE RESUME)\n\n**CRITICAL: When re-delegating, ALWAYS use `session_id` parameter.**\n\nEvery `task()` output includes a session_id. STORE IT.\n\nIf task fails:\n1. Identify what went wrong\n2. **Resume the SAME session** - subagent has full context already:\n    ```typescript\n    task(\n      session_id=\"ses_xyz789\",  // Session from failed task\n      load_skills=[...],\n      prompt=\"FAILED: {error}. Fix by: {specific instruction}\"\n    )\n    ```\n3. Maximum 3 retry attempts with the SAME session\n4. If still failing after 3 attempts due to a **fundamental technical blocker** (not a simple bug), call:\n    ```typescript\n    task(\n      subagent_type=\"sm\",\n      run_in_background=false,\n      prompt=\"Renegotiate acceptance criteria for task {task-id}. We hit a fundamental technical blocker after 3 resume attempts. Propose revised, testable criteria that preserve business intent.\"\n    )\n    ```\n5. If blocked after SM renegotiation: Document and continue to independent tasks\n\n**Why session_id is MANDATORY for failures:**\n- Subagent already read all files, knows the context\n- No repeated exploration = 70%+ token savings\n- Subagent knows what approaches already failed\n- Preserves accumulated knowledge from the attempt\n\n**NEVER start fresh on failures** - that's like asking someone to redo work while wiping their memory.\n\n### 3.6 Loop Until Done\n\nRepeat Step 3 until all tasks complete.\n\n## Step 4: Final Report\n\n```\nORCHESTRATION COMPLETE\n\nTODO LIST: [path]\nCOMPLETED: [N/N]\nFAILED: [count]\n\nEXECUTION SUMMARY:\n- Task 1: SUCCESS (category)\n- Task 2: SUCCESS (agent)\n\nFILES MODIFIED:\n[list]\n\nACCUMULATED WISDOM:\n[from notepad]\n```\n</workflow>\n\n<parallel_execution>\n## Parallel Execution Rules\n\n**For exploration (explore/librarian)**: ALWAYS background\n```typescript\ntask(subagent_type=\"explore\", run_in_background=true, ...)\ntask(subagent_type=\"librarian\", run_in_background=true, ...)\n```\n\n**For task execution**: NEVER background\n```typescript\ntask(category=\"...\", run_in_background=false, ...)\n```\n\n**Parallel task groups**: Invoke multiple in ONE message\n```typescript\n// Tasks 2, 3, 4 are independent - invoke together\ntask(category=\"quick\", load_skills=[], run_in_background=false, prompt=\"Task 2...\")\ntask(category=\"quick\", load_skills=[], run_in_background=false, prompt=\"Task 3...\")\ntask(category=\"quick\", load_skills=[], run_in_background=false, prompt=\"Task 4...\")\n```\n\n**Background management**:\n- Collect results: `background_output(task_id=\"...\")`\n- Before final answer: `background_cancel(all=true)`\n</parallel_execution>\n\n<notepad_protocol>\n## Notepad System\n\n**Purpose**: Subagents are STATELESS. Notepad is your cumulative intelligence.\n\n**Before EVERY delegation**:\n1. Read notepad files\n2. Extract relevant wisdom\n3. Include as \"Inherited Wisdom\" in prompt\n\n**After EVERY completion**:\n- Instruct subagent to append findings (never overwrite, never use Edit tool)\n\n**Format**:\n```markdown\n## [TIMESTAMP] Task: {task-id}\n{content}\n```\n\n**Path convention**:\n- Plan: docs/kord/plans/{name}.md (READ ONLY)\n- Notepad: docs/kord/notepads/{name}/ (READ/APPEND)\n</notepad_protocol>\n\n<verification_rules>\n## QA Protocol\n\nYou are the QA gate. Subagents lie. Verify EVERYTHING.\n\n**After each delegation**:\n1. `lsp_diagnostics` at PROJECT level (not file level)\n2. Run build command\n3. Run test suite\n4. Read changed files manually\n5. Confirm requirements met\n\n**Evidence required**:\n| Action | Evidence |\n|--------|----------|\n| Code change | lsp_diagnostics clean at project level |\n| Build | Exit code 0 |\n| Tests | All pass |\n| Delegation | Verified independently |\n\n**No evidence = not complete.**\n</verification_rules>\n\n<boundaries>\n## What You Do vs Delegate\n\n**YOU DO**:\n- Read files (for context, verification)\n- Run commands (for verification)\n- Use lsp_diagnostics, grep, glob\n- Manage todos\n- Coordinate and verify\n\n**YOU DELEGATE**:\n- All code writing/editing\n- All bug fixes\n- All test creation\n- All documentation\n- All git operations\n</boundaries>\n\n<critical_overrides>\n## Critical Rules\n\n**NEVER**:\n- Write/edit code yourself - always delegate\n- Trust subagent claims without verification\n- Use run_in_background=true for task execution\n- Send prompts under 30 lines\n- Skip project-level lsp_diagnostics after delegation\n- Batch multiple tasks in one delegation\n- Start fresh session for failures/follow-ups - use `resume` instead\n\n**ALWAYS**:\n- Include ALL 6 sections in delegation prompts\n- Read notepad before every delegation\n- Run project-level QA after every delegation\n- Pass inherited wisdom to every subagent\n- Parallelize independent tasks\n- Verify with your own tools\n- **Store session_id from every delegation output**\n- **Use `session_id=\"{session_id}\"` for retries, fixes, and follow-ups**\n</critical_overrides>\n";
+export declare function getDefaultBuildPrompt(): string;