oh-my-parallel-agent-opencode 0.1.0 → 0.2.1

package/LICENSE.md

@@ -0,0 +1,82 @@
+# License
+
+Portions of this software are licensed as follows:
+
+- All third party components incorporated into the oh-my-parallel-agent-opencode 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

@@ -1,77 +1,140 @@
 # oh-my-parallel-agent-opencode
 
-OpenCode 환경에서 여러 에이전트를 병렬로 관리하고 실행할 수 있게 해주는 플러그인입니다. `librarian`, `explore`, `metis`, `momus`와 같은 기본 에이전트들을 바탕으로, 사용자가 원하는 모델과 설정을 가진 커스텀 에이전트들을 동적으로 생성하여 병렬 작업을 수행할 수 있습니다.
+[oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode)에서 포크된 병렬 에이전트 플러그인입니다.
 
-## 주요 기능
+**momus-1, momus-2, metis-1, librarian-1, explore-1** 등 변형 에이전트를 지원합니다.
 
-- **동적 에이전트 생성**: 설정 파일을 통해 `momus-1`, `momus-2` 등 이름이 지정된 커스텀 에이전트를 무제한으로 생성할 수 있습니다.
-- **병렬 실행 지원**: 생성된 에이전트들은 `delegate_task` (또는 `call_omo_agent`)를 통해 백그라운드에서 병렬로 실행될 수 있습니다.
-- **모델 자유 선택**: 각 에이전트마다 서로 다른 LLM 모델(OpenAI, Anthropic, Google 등)을 할당할 수 있습니다.
+## 핵심 기능
 
-## 설치 방법
+- **4개 에이전트의 변형 지원**: `momus`, `metis`, `librarian`, `explore`
+- **변형 패턴**: `{agent}-{n}` (예: `momus-1`, `metis-2`, `librarian-3`)
+- **동일 프롬프트, 다른 설정**: 변형 에이전트는 base 에이전트와 동일한 프롬프트를 사용하지만 model/variant를 다르게 설정 가능
 
-프로젝트 루트 디렉토리의 `package.json`에 의존성을 추가하거나, 개발 환경에서 `npm link`를 사용하여 설치할 수 있습니다.
+## 설치
 
 ```bash
-# 개발 환경에서 링크하여 사용 시
-npm link oh-my-parallel-agent-opencode
+npm install oh-my-parallel-agent-opencode
 ```
 
-## 설정 방법
+## 설정
 
-프로젝트 루트 디렉토리에 `oh-my-parallel-agent.json` 파일을 생성하여 에이전트들을 정의합니다.
-
-### 설정 파일 형식 (`oh-my-parallel-agent.json`)
+### 1. OpenCode에 플러그인 등록
 
+`~/.config/opencode/opencode.json`:
 ```json
 {
+  "plugin": ["oh-my-parallel-agent-opencode"]
+}
+```
+
+### 2. 플러그인 설정 파일 생성
+
+`~/.config/opencode/oh-my-parallel-agent-opencode.jsonc`:
+```jsonc
+{
+  "$schema": "https://raw.githubusercontent.com/noseung-gyeong/oh-my-parallel-agent-opencode/master/assets/oh-my-parallel-agent-opencode.schema.json",
+  
+  // 변형 에이전트 정의
   "agents": {
+    // momus-1: Claude Sonnet 사용
     "momus-1": {
-      "model": "openai/gpt-5.2",
-      "temperature": 0.7
+      "model": "claude-sonnet-4-20250514"
     },
+    
+    // momus-2: GPT-4o 사용
     "momus-2": {
-      "model": "anthropic/claude-opus-4",
-      "prompt_append": "항상 비판적인 시각으로 검토해주세요."
+      "model": "gpt-4o"
     },
-    "librarian-research": {
-      "model": "google/gemini-3-pro"
+    
+    // metis-1: 다른 모델로
+    "metis-1": {
+      "model": "gemini-2.5-pro"
+    },
+    
+    // librarian-1, explore-1 등도 동일하게 정의
+    "librarian-1": {
+      "model": "claude-haiku-4-20250514"
+    },
+    
+    "explore-1": {
+      "model": "claude-haiku-4-20250514"
     }
   }
 }
 ```
 
-- **에이전트 이름 규칙**: `{기본에이전트명}-{식별자}` 형식을 사용합니다.
-  - 예: `momus-1`, `explore-web`, `librarian-docs`
-- **지원하는 기본 에이전트**: `librarian`, `explore`, `metis`, `momus`
+## 사용법
 
-## 사용 방법
+### delegate_task에서 변형 에이전트 호출
 
-플러그인이 로드되면 설정한 에이전트들이 OpenCode에 등록됩니다. 다음과 같이 `delegate_task` 도구를 사용하여 병렬로 호출할 수 있습니다.
+```typescript
+// momus-1 호출 (momus 프롬프트 + momus-1 설정 사용)
+delegate_task(
+  subagent_type="momus-1",
+  prompt="계획을 검토해주세요"
+)
+
+// momus-2 호출 (momus 프롬프트 + momus-2 설정 사용)
+delegate_task(
+  subagent_type="momus-2", 
+  prompt="다른 관점에서 검토해주세요"
+)
+```
 
-### 예시: 여러 모델에게 동시에 검증 요청하기
+### 병렬로 여러 변형 에이전트 실행
 
 ```typescript
-// momus-1과 momus-2에게 병렬로 검토 요청
-await ctx.callTool("delegate_task", {
-  subagent_type: "momus-1",
-  prompt: "현재 작성된 계획서의 논리적 허점을 찾아줘.",
-  run_in_background: true
-});
-
-await ctx.callTool("delegate_task", {
-  subagent_type: "momus-2",
-  prompt: "현재 작성된 계획서의 논리적 허점을 찾아줘.",
-  run_in_background: true
-});
+// 같은 작업을 다른 모델로 병렬 실행
+delegate_task(subagent_type="momus-1", run_in_background=true, prompt="...")
+delegate_task(subagent_type="momus-2", run_in_background=true, prompt="...")
 ```
 
-`run_in_background: true` 옵션을 사용하면 여러 에이전트가 동시에 작업을 시작하며, `background_output` 도구를 통해 각 에이전트의 진행 상태와 결과를 확인할 수 있습니다.
+## 지원 에이전트
 
-## 테스트 실행
+| Base 에이전트 | 변형 패턴 | 설명 |
+|--------------|----------|------|
+| `momus` | `momus-1`, `momus-2`, ... | 계획 검토 에이전트 |
+| `metis` | `metis-1`, `metis-2`, ... | 사전 계획 컨설턴트 |
+| `librarian` | `librarian-1`, `librarian-2`, ... | 문서/코드 검색 에이전트 |
+| `explore` | `explore-1`, `explore-2`, ... | 코드베이스 탐색 에이전트 |
 
-```bash
-bun test
+## 동작 원리
+
+1. `delegate_task(subagent_type="momus-1", ...)`로 호출
+2. 플러그인이 `momus-1`에서 base 에이전트 `momus` 파싱
+3. `momus`의 프롬프트/팩토리 사용
+4. 설정 파일에서 `momus-1`의 model/variant 적용
+5. 에이전트 실행
+
+```
+사용자 → delegate_task("momus-1")
+         ↓
+플러그인 → resolveBaseAgent("momus-1") → "momus"
+         ↓
+         → momus 프롬프트 로드
+         → momus-1 설정 (model 등) 적용
+         ↓
+실행 ←───┘
 ```
 
-현재 46개의 단위 테스트 및 통합 테스트가 포함되어 있으며, 에이전트 생성 로직과 설정 파일 파싱 로직의 안정성을 보장합니다.
+## oh-my-opencode와의 차이점
+
+| 항목 | oh-my-opencode | oh-my-parallel-agent-opencode |
+|------|----------------|-------------------------------|
+| 에이전트 | 전체 (sisyphus, oracle 등) | 4개만 (momus, metis, librarian, explore) |
+| 변형 지원 | ❌ | ✅ `{agent}-{n}` 패턴 |
+| 용도 | 전체 에이전트 시스템 | 병렬 검토/탐색에 특화 |
+
+## 설정 파일 위치
+
+- **플러그인 설정**: `~/.config/opencode/oh-my-parallel-agent-opencode.jsonc`
+- **OpenCode 설정**: `~/.config/opencode/opencode.json`
+
+## 라이선스
+
+[SUL-1.0](LICENSE.md)
+
+## 관련 프로젝트
+
+- [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode) - 원본 프로젝트
+- [OpenCode](https://github.com/sst/opencode) - 기반 CLI

package/bin/oh-my-parallel-agent-opencode.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// bin/oh-my-parallel-agent-opencode.js
+// Wrapper script that detects platform and spawns the correct binary
+
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+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(`\noh-my-parallel-agent-opencode: ${error.message}\n`);
+    process.exit(1);
+  }
+  
+  // Resolve binary path
+  const binRelPath = getBinaryPath(pkg, platform);
+  
+  let binPath;
+  try {
+    binPath = require.resolve(binRelPath);
+  } catch {
+    console.error(`\noh-my-parallel-agent-opencode: 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(`\noh-my-parallel-agent-opencode: 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 "oh-my-parallel-agent-opencode-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 `oh-my-parallel-agent-opencode-${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 "oh-my-parallel-agent-opencode-darwin-arm64/bin/oh-my-parallel-agent-opencode"
+ */
+export function getBinaryPath(pkg, platform) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return `${pkg}/bin/oh-my-parallel-agent-opencode${ext}`;
+}

package/bin/platform.test.ts

@@ -0,0 +1,148 @@
+// bin/platform.test.ts
+import { describe, expect, test } from "bun:test";
+import { getPlatformPackage, getBinaryPath } from "./platform.js";
+
+describe("getPlatformPackage", () => {
+  // #region Darwin platforms
+  test("returns darwin-arm64 for macOS ARM64", () => {
+    // #given macOS ARM64 platform
+    const input = { platform: "darwin", arch: "arm64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("oh-my-parallel-agent-opencode-darwin-arm64");
+  });
+
+  test("returns darwin-x64 for macOS Intel", () => {
+    // #given macOS x64 platform
+    const input = { platform: "darwin", arch: "x64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("oh-my-parallel-agent-opencode-darwin-x64");
+  });
+  // #endregion
+
+  // #region Linux glibc platforms
+  test("returns linux-x64 for Linux x64 with glibc", () => {
+    // #given Linux x64 with glibc
+    const input = { platform: "linux", arch: "x64", libcFamily: "glibc" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("oh-my-parallel-agent-opencode-linux-x64");
+  });
+
+  test("returns linux-arm64 for Linux ARM64 with glibc", () => {
+    // #given Linux ARM64 with glibc
+    const input = { platform: "linux", arch: "arm64", libcFamily: "glibc" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name
+    expect(result).toBe("oh-my-parallel-agent-opencode-linux-arm64");
+  });
+  // #endregion
+
+  // #region Linux musl platforms
+  test("returns linux-x64-musl for Alpine x64", () => {
+    // #given Linux x64 with musl (Alpine)
+    const input = { platform: "linux", arch: "x64", libcFamily: "musl" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with musl suffix
+    expect(result).toBe("oh-my-parallel-agent-opencode-linux-x64-musl");
+  });
+
+  test("returns linux-arm64-musl for Alpine ARM64", () => {
+    // #given Linux ARM64 with musl (Alpine)
+    const input = { platform: "linux", arch: "arm64", libcFamily: "musl" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with musl suffix
+    expect(result).toBe("oh-my-parallel-agent-opencode-linux-arm64-musl");
+  });
+  // #endregion
+
+  // #region Windows platform
+  test("returns windows-x64 for Windows", () => {
+    // #given Windows x64 platform (win32 is Node's platform name)
+    const input = { platform: "win32", arch: "x64" };
+
+    // #when getting platform package
+    const result = getPlatformPackage(input);
+
+    // #then returns correct package name with 'windows' not 'win32'
+    expect(result).toBe("oh-my-parallel-agent-opencode-windows-x64");
+  });
+  // #endregion
+
+  // #region Error cases
+  test("throws error for Linux with null libcFamily", () => {
+    // #given Linux platform with null libc detection
+    const input = { platform: "linux", arch: "x64", libcFamily: null };
+
+    // #when getting platform package
+    // #then throws descriptive error
+    expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
+  });
+
+  test("throws error for Linux with undefined libcFamily", () => {
+    // #given Linux platform with undefined libc
+    const input = { platform: "linux", arch: "x64", libcFamily: undefined };
+
+    // #when getting platform package
+    // #then throws descriptive error
+    expect(() => getPlatformPackage(input)).toThrow("Could not detect libc");
+  });
+  // #endregion
+});
+
+describe("getBinaryPath", () => {
+  test("returns path without .exe for Unix platforms", () => {
+    // #given Unix platform package
+    const pkg = "oh-my-parallel-agent-opencode-darwin-arm64";
+    const platform = "darwin";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path without extension
+    expect(result).toBe("oh-my-parallel-agent-opencode-darwin-arm64/bin/oh-my-parallel-agent-opencode");
+  });
+
+  test("returns path with .exe for Windows", () => {
+    // #given Windows platform package
+    const pkg = "oh-my-parallel-agent-opencode-windows-x64";
+    const platform = "win32";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path with .exe extension
+    expect(result).toBe("oh-my-parallel-agent-opencode-windows-x64/bin/oh-my-parallel-agent-opencode.exe");
+  });
+
+  test("returns path without .exe for Linux", () => {
+    // #given Linux platform package
+    const pkg = "oh-my-parallel-agent-opencode-linux-x64";
+    const platform = "linux";
+
+    // #when getting binary path
+    const result = getBinaryPath(pkg, platform);
+
+    // #then returns path without extension
+    expect(result).toBe("oh-my-parallel-agent-opencode-linux-x64/bin/oh-my-parallel-agent-opencode");
+  });
+});

package/dist/agents/atlas.d.ts

@@ -0,0 +1,22 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+import type { AvailableAgent, AvailableSkill } from "./dynamic-agent-prompt-builder";
+import type { CategoryConfig } from "../config/schema";
+/**
+ * Atlas - Master Orchestrator Agent
+ *
+ * Orchestrates work via delegate_task() to complete ALL tasks in a todo list until fully done.
+ * You are the conductor of a symphony of specialized agents.
+ */
+export interface OrchestratorContext {
+    model?: string;
+    availableAgents?: AvailableAgent[];
+    availableSkills?: AvailableSkill[];
+    userCategories?: Record<string, CategoryConfig>;
+}
+export declare const ATLAS_SYSTEM_PROMPT = "\n<identity>\nYou are Atlas - the Master Orchestrator from OhMyOpenCode.\n\nIn Greek mythology, Atlas holds up the celestial heavens. You hold up the entire workflow - 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 `delegate_task()` until fully done.\nOne task per delegation. Parallel when independent. Verify everything.\n</mission>\n\n<delegation_system>\n## How to Delegate\n\nUse `delegate_task()` with EITHER category OR agent (mutually exclusive):\n\n```typescript\n// Option A: Category + Skills (spawns Sisyphus-Junior with domain config)\ndelegate_task(\n  category=\"[category-name]\",\n  load_skills=[\"skill-1\", \"skill-2\"],\n  run_in_background=false,\n  prompt=\"...\"\n)\n\n// Option B: Specialized Agent (for specific expert tasks)\ndelegate_task(\n  subagent_type=\"[agent-name]\",\n  load_skills=[],\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## 6-Section Prompt Structure (MANDATORY)\n\nEvery `delegate_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: .sisyphus/notepads/{plan-name}/*.md\n- WRITE: Append to appropriate category\n\n### Inherited Wisdom\n[From notepad - conventions, gotchas, decisions]\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 .sisyphus/notepads/{plan-name}\n```\n\nStructure:\n```\n.sisyphus/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 `delegate_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(\".sisyphus/notepads/{plan-name}/*.md\")\nRead(\".sisyphus/notepads/{plan-name}/learnings.md\")\nRead(\".sisyphus/notepads/{plan-name}/issues.md\")\n```\n\nExtract wisdom and include in prompt.\n\n### 3.3 Invoke delegate_task()\n\n```typescript\ndelegate_task(\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\ndelegate_task(\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 `delegate_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    delegate_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 blocked after 3 attempts: 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\ndelegate_task(subagent_type=\"explore\", run_in_background=true, ...)\ndelegate_task(subagent_type=\"librarian\", run_in_background=true, ...)\n```\n\n**For task execution**: NEVER background\n```typescript\ndelegate_task(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\ndelegate_task(category=\"quick\", prompt=\"Task 2...\")\ndelegate_task(category=\"quick\", prompt=\"Task 3...\")\ndelegate_task(category=\"quick\", 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: `.sisyphus/plans/{name}.md` (READ ONLY)\n- Notepad: `.sisyphus/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 createAtlasAgent(ctx: OrchestratorContext): AgentConfig;
+export declare namespace createAtlasAgent {
+    var mode: "primary";
+}
+export declare const atlasPromptMetadata: AgentPromptMetadata;

package/dist/agents/dynamic-agent-prompt-builder.d.ts

@@ -0,0 +1,30 @@
+import type { AgentPromptMetadata, BuiltinAgentName } from "./types";
+export interface AvailableAgent {
+    name: BuiltinAgentName;
+    description: string;
+    metadata: AgentPromptMetadata;
+}
+export interface AvailableTool {
+    name: string;
+    category: "lsp" | "ast" | "search" | "session" | "command" | "other";
+}
+export interface AvailableSkill {
+    name: string;
+    description: string;
+    location: "user" | "project" | "plugin";
+}
+export interface AvailableCategory {
+    name: string;
+    description: string;
+}
+export declare function categorizeTools(toolNames: string[]): AvailableTool[];
+export declare function buildKeyTriggersSection(agents: AvailableAgent[], _skills?: AvailableSkill[]): string;
+export declare function buildToolSelectionTable(agents: AvailableAgent[], tools?: AvailableTool[], _skills?: AvailableSkill[]): string;
+export declare function buildExploreSection(agents: AvailableAgent[]): string;
+export declare function buildLibrarianSection(agents: AvailableAgent[]): string;
+export declare function buildDelegationTable(agents: AvailableAgent[]): string;
+export declare function buildCategorySkillsDelegationGuide(categories: AvailableCategory[], skills: AvailableSkill[]): string;
+export declare function buildOracleSection(agents: AvailableAgent[]): string;
+export declare function buildHardBlocksSection(): string;
+export declare function buildAntiPatternsSection(): string;
+export declare function buildUltraworkSection(agents: AvailableAgent[], categories: AvailableCategory[], skills: AvailableSkill[]): string;

package/dist/agents/explore.d.ts

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

package/dist/agents/hephaestus.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AvailableAgent, AvailableSkill, AvailableCategory } from "./dynamic-agent-prompt-builder";
+export declare function createHephaestusAgent(model: string, availableAgents?: AvailableAgent[], availableToolNames?: string[], availableSkills?: AvailableSkill[], availableCategories?: AvailableCategory[]): AgentConfig;
+export declare namespace createHephaestusAgent {
+    var mode: "primary";
+}

package/dist/agents/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types";
+export { createBuiltinAgents } from "./utils";
+export type { AvailableAgent, AvailableCategory, AvailableSkill } from "./dynamic-agent-prompt-builder";
+export { createSisyphusAgent } from "./sisyphus";
+export { createOracleAgent, ORACLE_PROMPT_METADATA } from "./oracle";
+export { createLibrarianAgent, LIBRARIAN_PROMPT_METADATA } from "./librarian";
+export { createExploreAgent, EXPLORE_PROMPT_METADATA } from "./explore";
+export { createMultimodalLookerAgent, MULTIMODAL_LOOKER_PROMPT_METADATA } from "./multimodal-looker";
+export { createMetisAgent, METIS_SYSTEM_PROMPT, metisPromptMetadata } from "./metis";
+export { createMomusAgent, MOMUS_SYSTEM_PROMPT, momusPromptMetadata } from "./momus";
+export { createAtlasAgent, atlasPromptMetadata } from "./atlas";
+export { PROMETHEUS_SYSTEM_PROMPT, PROMETHEUS_PERMISSION, PROMETHEUS_IDENTITY_CONSTRAINTS, PROMETHEUS_INTERVIEW_MODE, PROMETHEUS_PLAN_GENERATION, PROMETHEUS_HIGH_ACCURACY_MODE, PROMETHEUS_PLAN_TEMPLATE, PROMETHEUS_BEHAVIORAL_SUMMARY, } from "./prometheus";

package/dist/agents/librarian.d.ts

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