opencode-ultra 0.7.7 → 0.8.1

package/README.md

@@ -4,7 +4,7 @@ OpenCode 1.2.x プラグイン。マルチエージェントオーケストレ
 
 ## 機能一覧
 
-### ツール (9)
+### ツール (12)
 
 | ツール | 説明 |
 |--------|------|
@@ -16,7 +16,10 @@ OpenCode 1.2.x プラグイン。マルチエージェントオーケストレ
 | `ledger_load` | Continuity Ledger の読み込み (名前指定 or 最新) |
 | `ast_search` | AST-aware コード検索 (ast-grep/sg バイナリ使用、未インストール時は自動スキップ) |
 | `evolve_apply` | プラグイン推薦の信頼度スコア評価 + OpenCode 設定への自動適用 (dry-run/backup 対応) |
+| `evolve_scan` | 改善提案 JSONL の検証・マージ・スコアリング・番号付きレポート生成 |
 | `evolve_score` | 改善提案のスコアリング・ランキング (Priority x Effort 重み付け) |
+| `evolve_exe` | 提案の自律実行パイプライン (git branch → implement → test → build → review → merge/rollback) |
+| `evolve_publish` | バージョンアップ + テスト + ビルド + npm publish (デプロイ手順出力対応) |
 
 ### フック (9)
 
@@ -70,7 +73,32 @@ OpenCode 1.2.x プラグイン。マルチエージェントオーケストレ
 
 P0+Low=30 (最優先) / P2+High=1 (最低)
 
-evolve は**提案のみ**。適用は人間が判断する。
+### Evolve Execution (自律実行)
+
+提案の実装を `evolve_exe` で完全自動化できる。各提案ごとに git branch で隔離し、失敗時は自動ロールバック。
+
+```
+evolve_exe({ proposals: "1,3" })              — 提案 #1 と #3 を自律実行
+evolve_exe({ proposals: "all" })               — accepted 全提案を実行
+evolve_exe({ proposals: "1", dryRun: true })   — 実行プランのみ表示
+evolve_exe({ proposals: "1,2", publish: true }) — 実行後に自動 publish
+```
+
+| Phase | 内容 |
+|-------|------|
+| 1. GIT BRANCH | `evolve/{slug}` ブランチ作成 |
+| 2. IMPLEMENT | hephaestus が ralph_loop パターンで自律実装 |
+| 3. TEST | `bun test` 実行 (失敗 → rollback) |
+| 4. BUILD | `bun run build` 実行 (失敗 → rollback) |
+| 5. REVIEW | momus がコードレビュー (BLOCK はログ記録) |
+| 6. MERGE | `--no-ff` で元ブランチにマージ、ブランチ削除 |
+
+実装後のパブリッシュ:
+
+```
+evolve_publish({ bump: "patch" })                    — test → build → version bump → npm publish
+evolve_publish({ bump: "minor", deploy: "ssh-124" }) — publish + SSH デプロイ手順出力
+```
 
 ## エージェント構成
 
@@ -147,7 +175,8 @@ Sisyphus (オーケストレーター) が読み込み・分析・計画を行
                           // fragment-injector, prompt-renderer, comment-checker,
                           // token-truncation, todo-enforcer, session-compaction
   "disabled_tools": [],   // spawn_agent, ralph_loop, cancel_ralph, batch_read,
-                          // ledger_save, ledger_load, ast_search, evolve_apply, evolve_score
+                          // ledger_save, ledger_load, ast_search, evolve_apply,
+                          // evolve_scan, evolve_score, evolve_exe, evolve_publish
   "disabled_mcps": [],    // context7
 
   // Built-in Agent Demotion (default: true)
@@ -166,6 +195,14 @@ Sisyphus (オーケストレーター) が読み込み・分析・計画を行
     "agentTimeoutMs": 180000
   },
 
+  // Evolve Execution
+  "evolve_exe": {
+    "maxIterations": 10,         // hephaestus の最大イテレーション (1-20)
+    "iterationTimeoutMs": 300000, // per-iteration タイムアウト
+    "skipReview": false,          // momus レビューをスキップ
+    "skipTests": false            // bun test をスキップ
+  },
+
   // Token Truncation
   "token_truncation": { "maxChars": 30000 },
 

package/dist/config.d.ts

@@ -73,6 +73,12 @@ declare const PluginConfigSchema: z.ZodObject<{
         maxTotalSpawned: z.ZodOptional<z.ZodNumber>;
         agentTimeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    evolve_exe: z.ZodOptional<z.ZodObject<{
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        iterationTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        skipReview: z.ZodOptional<z.ZodBoolean>;
+        skipTests: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$loose>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export declare function parsePluginConfig(raw: unknown): PluginConfig;

package/dist/index.js

@@ -14472,6 +14472,12 @@ var PluginConfigSchema = exports_external.object({
   safety: exports_external.object({
     maxTotalSpawned: exports_external.number().min(1).optional(),
     agentTimeoutMs: exports_external.number().min(1000).optional()
+  }).optional(),
+  evolve_exe: exports_external.object({
+    maxIterations: exports_external.number().min(1).max(20).optional(),
+    iterationTimeoutMs: exports_external.number().min(1e4).optional(),
+    skipReview: exports_external.boolean().optional(),
+    skipTests: exports_external.boolean().optional()
   }).optional()
 }).passthrough();
 function parsePluginConfig(raw) {
@@ -14530,7 +14536,8 @@ function mergeConfigs(base, override) {
     ])],
     background_task: override.background_task ?? base.background_task,
     comment_checker: override.comment_checker ?? base.comment_checker,
-    todo_enforcer: override.todo_enforcer ?? base.todo_enforcer
+    todo_enforcer: override.todo_enforcer ?? base.todo_enforcer,
+    evolve_exe: override.evolve_exe ?? base.evolve_exe
   };
 }
 function detectConfigFile(basePath) {
@@ -14982,6 +14989,17 @@ ledger_save({
 })
 \`\`\`
 
+## EXECUTION MODE
+
+After proposals are scored and saved, the user can execute them:
+- \`evolve_exe({ proposals: "1,3" })\` \u2014 Implement proposals #1 and #3 autonomously
+- \`evolve_exe({ proposals: "all" })\` \u2014 Implement all accepted proposals
+- \`evolve_exe({ proposals: "1", dryRun: true })\` \u2014 Preview execution plan
+- \`evolve_exe({ proposals: "1,2", publish: true })\` \u2014 Implement + auto-publish
+
+Each proposal runs on a git branch. Failed proposals are rolled back automatically.
+After implementation: \`evolve_publish({ bump: "patch" })\` to publish.
+
 ## RULES
 - Use the capability inventory above as ground truth.
 - Do NOT use evolve_apply. Proposals only. Humans decide what to implement.
@@ -28603,6 +28621,72 @@ function formatResult(result) {
 }
 
 // src/tools/evolve-filter.ts
+var EvolveProposalSchema = exports_external.object({
+  title: exports_external.string().min(1),
+  priority: exports_external.enum(["P0", "P1", "P2"]),
+  effort: exports_external.enum(["Low", "Medium", "High"]),
+  description: exports_external.string().optional(),
+  files: exports_external.array(exports_external.string()).optional(),
+  currentState: exports_external.string().optional(),
+  inspiration: exports_external.string().optional(),
+  current_state: exports_external.string().optional(),
+  why: exports_external.string().optional(),
+  how: exports_external.string().optional()
+}).transform((v) => {
+  const legacyDesc = [v.why, v.how].filter((s) => typeof s === "string" && s.length > 0);
+  return {
+    title: v.title,
+    priority: v.priority,
+    effort: v.effort,
+    description: v.description ?? (legacyDesc.length > 0 ? legacyDesc.join(`
+`) : ""),
+    files: v.files,
+    currentState: v.currentState ?? v.current_state,
+    inspiration: v.inspiration
+  };
+});
+function validateProposalJsonl(line) {
+  const raw = line.trim();
+  if (!raw)
+    return { ok: false, error: "Empty line" };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Invalid JSON: ${msg}` };
+  }
+  const result = EvolveProposalSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => {
+      const path8 = i.path.length > 0 ? i.path.join(".") : "(root)";
+      return `${path8}: ${i.message}`;
+    }).join("; ");
+    return { ok: false, error: `Schema validation failed: ${issues}` };
+  }
+  return { ok: true, proposal: result.data };
+}
+function normalizeTitleForDedup(title) {
+  return title.normalize("NFKC").toLowerCase().replace(/[\p{P}\p{S}\s]+/gu, "").trim();
+}
+function deduplicateProposals(existing, incoming) {
+  const seen = new Set;
+  const out = [];
+  const add = (p) => {
+    const key = normalizeTitleForDedup(p.title);
+    if (key.length === 0)
+      return;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    out.push(p);
+  };
+  for (const p of existing)
+    add(p);
+  for (const p of incoming)
+    add(p);
+  return out;
+}
 var PRIORITY_WEIGHT = {
   P0: 10,
   P1: 5,
@@ -28756,6 +28840,791 @@ evolve_score({ markdown: "## Improvement: Rate Limiting\\n**Priority**: P0\\n**E
   });
 }
 
+// src/tools/evolve-scan.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+function splitJsonl(text) {
+  return text.split(/\r?\n/);
+}
+function parseJsonl(text) {
+  const proposals = [];
+  const errors5 = [];
+  const lines = splitJsonl(text);
+  for (let i = 0;i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    if (!raw.trim())
+      continue;
+    const v = validateProposalJsonl(raw);
+    if (v.ok === false) {
+      errors5.push({ line: i + 1, raw, error: v.error });
+      continue;
+    }
+    proposals.push(v.proposal);
+  }
+  return { proposals, errors: errors5 };
+}
+function proposalToJson(p) {
+  const out = {
+    title: p.title,
+    priority: p.priority,
+    effort: p.effort,
+    description: p.description
+  };
+  if (p.files && p.files.length > 0)
+    out.files = p.files;
+  if (p.currentState)
+    out.currentState = p.currentState;
+  if (p.inspiration)
+    out.inspiration = p.inspiration;
+  return out;
+}
+function formatMaybeCode(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function markdownEscape(s) {
+  return s.replaceAll("|", "\\|").replaceAll(`
+`, " ");
+}
+function buildReport(args) {
+  const lines = [];
+  lines.push("# Evolve Scan Report");
+  lines.push("");
+  lines.push("## Metadata");
+  lines.push(`- Generated: ${args.generatedAt}`);
+  lines.push(`- Search query: ${args.query && args.query.trim() ? args.query.trim() : "(not provided)"}`);
+  lines.push(`- Threshold: minScore=${args.minScore}, maxProposals=${args.maxProposals}`);
+  lines.push(`- Proposals: existing=${args.existingCount}, incoming=${args.incomingCount}, merged=${args.mergedCount}, accepted=${args.acceptedCount}, rejected=${args.rejectedCount}`);
+  lines.push(`- Invalid JSONL lines skipped: ${args.existingErrors.length + args.incomingErrors.length}`);
+  lines.push("");
+  lines.push("## Feature Matrix");
+  lines.push("");
+  if (args.featureMatrix && args.featureMatrix.trim()) {
+    lines.push(args.featureMatrix.trim());
+  } else {
+    lines.push("_(not provided)_");
+  }
+  lines.push("");
+  lines.push("## Scored Proposals");
+  lines.push("");
+  lines.push(`### Accepted (${args.accepted.length})`);
+  lines.push("");
+  if (args.accepted.length === 0) {
+    lines.push("_(none)_");
+  } else {
+    lines.push("| # | Title | Score | Priority | Effort | Description | Inspiration | Current state |");
+    lines.push("|---:|---|---:|---|---|---|---|---|");
+    for (const p of args.accepted) {
+      lines.push(`| #${p.index} | ${markdownEscape(p.title)} | ${p.score} | ${p.priority} | ${p.effort} | ${markdownEscape(formatMaybeCode(p.description))} | ${markdownEscape(p.inspiration ? formatMaybeCode(p.inspiration) : "")} | ${markdownEscape(p.currentState ? formatMaybeCode(p.currentState) : "")} |`);
+    }
+  }
+  lines.push("");
+  lines.push(`### Rejected (${args.rejected.length})`);
+  lines.push("");
+  if (args.rejected.length === 0) {
+    lines.push("_(none)_");
+  } else {
+    lines.push("| # | Title | Score | Priority | Effort | Reason |");
+    lines.push("|---:|---|---:|---|---|---|");
+    for (const p of args.rejected) {
+      lines.push(`| #${p.index} | ${markdownEscape(p.title)} | ${p.score} | ${p.priority} | ${p.effort} | ${markdownEscape(p.reason ? formatMaybeCode(p.reason) : "")} |`);
+    }
+  }
+  lines.push("");
+  const allErrors = [
+    ...args.existingErrors.map((e) => ({ ...e, source: "existing" })),
+    ...args.incomingErrors.map((e) => ({ ...e, source: "incoming" }))
+  ];
+  if (allErrors.length > 0) {
+    lines.push("## Skipped JSONL Lines");
+    lines.push("");
+    for (const e of allErrors) {
+      lines.push(`- ${e.source} line ${e.line}: ${e.error}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Score Reference");
+  lines.push("");
+  lines.push("P0+Low=30 | P0+Med=20 | P0+High=10 | P1+Low=15 | P1+Med=10 | P1+High=5 | P2+Low=3 | P2+Med=2 | P2+High=1");
+  lines.push("");
+  return lines.join(`
+`);
+}
+function createEvolveScanTool() {
+  return tool({
+    description: `Scan/validate evolve proposals JSONL, merge with existing proposals, score them, and generate a report.
+
+Writes outputs to:
+- .opencode/evolve-proposals.jsonl (validated, deduplicated)
+- .opencode/evolve-report.md (Feature Matrix + Scored Proposals + metadata)
+
+This tool only writes into .opencode/ and does not modify source code.`,
+    args: {
+      proposalsJsonl: tool.schema.string().optional().describe("Incoming proposals as raw JSONL text (optional; merged into existing file)"),
+      featureMatrix: tool.schema.string().optional().describe("Feature matrix markdown (Phase 2 output) to embed into the report"),
+      query: tool.schema.string().optional().describe("Search query used during research (for report metadata)"),
+      minScore: tool.schema.number().optional().describe("Minimum score to accept (default: 5)"),
+      maxProposals: tool.schema.number().optional().describe("Max proposals to accept (default: 3)")
+    },
+    execute: async (args) => {
+      const generatedAt = new Date().toISOString();
+      const minScore = args.minScore ?? 5;
+      const maxProposals = args.maxProposals ?? 3;
+      const outDir = path8.join(process.cwd(), ".opencode");
+      const proposalsPath = path8.join(outDir, "evolve-proposals.jsonl");
+      const reportPath = path8.join(outDir, "evolve-report.md");
+      fs8.mkdirSync(outDir, { recursive: true });
+      const existingText = fs8.existsSync(proposalsPath) ? fs8.readFileSync(proposalsPath, "utf-8") : "";
+      const existingParsed = existingText ? parseJsonl(existingText) : { proposals: [], errors: [] };
+      const incomingParsed = args.proposalsJsonl ? parseJsonl(args.proposalsJsonl) : { proposals: [], errors: [] };
+      const existingDeduped = deduplicateProposals([], existingParsed.proposals);
+      const merged = deduplicateProposals(existingDeduped, incomingParsed.proposals);
+      const addedCount = merged.length - existingDeduped.length;
+      const existingDupesRemoved = existingParsed.proposals.length - existingDeduped.length;
+      const incomingDupesSkipped = incomingParsed.proposals.length - addedCount;
+      const filtered = filterProposals(merged, { minScore, maxProposals });
+      const titleToIndex = new Map;
+      for (let i = 0;i < merged.length; i++) {
+        titleToIndex.set(merged[i].title, i + 1);
+      }
+      const accepted = filtered.filter((p) => p.accepted).map((p) => ({ ...p, score: p.score, index: titleToIndex.get(p.title) ?? 0 }));
+      const rejected = filtered.filter((p) => !p.accepted).map((p) => ({ ...p, score: p.score, reason: p.reason, index: titleToIndex.get(p.title) ?? 0 }));
+      const jsonlOut = merged.map((p) => JSON.stringify(proposalToJson(p))).join(`
+`) + (merged.length > 0 ? `
+` : "");
+      fs8.writeFileSync(proposalsPath, jsonlOut, "utf-8");
+      const report = buildReport({
+        generatedAt,
+        query: args.query,
+        minScore,
+        maxProposals,
+        featureMatrix: args.featureMatrix,
+        existingCount: existingParsed.proposals.length,
+        incomingCount: incomingParsed.proposals.length,
+        mergedCount: merged.length,
+        acceptedCount: accepted.length,
+        rejectedCount: rejected.length,
+        existingErrors: existingParsed.errors,
+        incomingErrors: incomingParsed.errors,
+        accepted: accepted.map((p) => ({ ...p, score: scoreProposal(p), index: p.index })),
+        rejected: rejected.map((p) => ({ ...p, score: scoreProposal(p), index: p.index }))
+      });
+      fs8.writeFileSync(reportPath, report, "utf-8");
+      const skippedInvalid = existingParsed.errors.length + incomingParsed.errors.length;
+      const proposalSummary = [...accepted, ...rejected].sort((a, b) => a.index - b.index).map((p) => `  #${p.index} ${p.title} (${p.priority}/${p.effort}, score=${scoreProposal(p)})${p.accepted ? "" : " [rejected]"}`);
+      return [
+        "## evolve_scan complete",
+        `- Wrote: ${proposalsPath}`,
+        `- Wrote: ${reportPath}`,
+        `- Existing proposals: ${existingParsed.proposals.length} (dedup removed ${existingDupesRemoved})`,
+        `- Incoming proposals: ${incomingParsed.proposals.length} (dedup skipped ${incomingDupesSkipped}, invalid skipped ${incomingParsed.errors.length})`,
+        `- Merged proposals: ${merged.length} (accepted ${accepted.length}, rejected ${rejected.length})`,
+        ...proposalSummary.length > 0 ? proposalSummary : [],
+        `- Invalid JSONL lines skipped (total): ${skippedInvalid}`
+      ].join(`
+`);
+    }
+  });
+}
+
+// src/tools/evolve-exe.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs9 from "fs";
+import * as path9 from "path";
+var COMPLETION_MARKER2 = "<promise>DONE</promise>";
+var DEFAULT_MAX_ITERATIONS2 = 10;
+var DEFAULT_ITERATION_TIMEOUT_MS2 = 300000;
+async function withTimeout3(promise3, ms, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Timeout: ${label} exceeded ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise3, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function readProposalsJsonl(cwd) {
+  const jsonlPath = path9.join(cwd, ".opencode", "evolve-proposals.jsonl");
+  if (!fs9.existsSync(jsonlPath)) {
+    return { proposals: [], raw: [] };
+  }
+  const text = fs9.readFileSync(jsonlPath, "utf-8");
+  const lines = text.split(/\r?\n/).filter((l) => l.trim());
+  const proposals = [];
+  const raw = [];
+  for (const line of lines) {
+    const v = validateProposalJsonl(line);
+    if (v.ok) {
+      proposals.push(v.proposal);
+      raw.push(line);
+    }
+  }
+  return { proposals, raw };
+}
+function selectProposals(proposals, selection) {
+  const errors5 = [];
+  if (selection.trim().toLowerCase() === "all") {
+    const filtered = filterProposals(proposals);
+    const accepted = filtered.filter((p) => p.accepted);
+    return {
+      selected: accepted.map((p) => {
+        const idx = proposals.findIndex((orig) => orig.title === p.title);
+        return { ...p, index: idx + 1 };
+      }),
+      errors: errors5
+    };
+  }
+  const indices = selection.split(",").map((s) => s.trim()).filter(Boolean).map((s) => parseInt(s, 10));
+  const selected = [];
+  for (const idx of indices) {
+    if (isNaN(idx) || idx < 1 || idx > proposals.length) {
+      errors5.push(`Invalid index: ${idx} (valid range: 1-${proposals.length})`);
+      continue;
+    }
+    selected.push({ ...proposals[idx - 1], index: idx });
+  }
+  return { selected, errors: errors5 };
+}
+function slugify2(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function gitCmd(args, cwd) {
+  const result = spawnSync2("git", args, { cwd, encoding: "utf-8", timeout: 30000 });
+  return {
+    ok: result.status === 0,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim()
+  };
+}
+function buildProjectInfo(cwd) {
+  try {
+    const pkg = JSON.parse(fs9.readFileSync(path9.join(cwd, "package.json"), "utf-8"));
+    const srcDir = path9.join(cwd, "src");
+    const testDir = path9.join(cwd, "__test__");
+    const srcFiles = fs9.existsSync(srcDir) ? fs9.readdirSync(srcDir, { recursive: true }).filter((f) => f.toString().endsWith(".ts")).map((f) => `src/${f}`) : [];
+    const testFiles = fs9.existsSync(testDir) ? fs9.readdirSync(testDir, { recursive: true }).filter((f) => f.toString().endsWith(".ts")).map((f) => `__test__/${f}`) : [];
+    return [
+      `- **Package**: ${pkg.name}@${pkg.version}`,
+      `- **Type**: ${pkg.type ?? "commonjs"}`,
+      `- **Build**: ${pkg.scripts?.build ?? "(none)"}`,
+      `- **Test**: ${pkg.scripts?.test ?? "(none)"}`,
+      `- **Source files**: ${srcFiles.join(", ")}`,
+      `- **Test files**: ${testFiles.join(", ")}`
+    ].join(`
+`);
+  } catch {
+    return "- (Could not read package.json)";
+  }
+}
+var IMPLEMENT_PROMPT = (proposal, projectInfo) => `
+[EVOLVE IMPLEMENTATION \u2014 AUTONOMOUS MODE]
+
+## Task
+Implement the following improvement proposal for this project:
+
+**Title**: ${proposal.title}
+**Priority**: ${proposal.priority} | **Effort**: ${proposal.effort}
+**Description**: ${proposal.description}
+${proposal.currentState ? `**Current State**: ${proposal.currentState}` : ""}
+${proposal.files?.length ? `**Target Files**: ${proposal.files.join(", ")}` : ""}
+${proposal.inspiration ? `**Inspiration**: ${proposal.inspiration}` : ""}
+
+## Project Context
+${projectInfo}
+
+## Requirements
+1. Implement the feature described above
+2. Write unit tests in \`__test__/\` directory (same naming pattern as existing tests)
+3. Ensure all existing tests still pass
+4. Follow existing code patterns and conventions:
+   - Use \`@opencode-ai/plugin\` tool() API for new tools
+   - Pure functions where possible, side effects isolated
+   - TypeScript strict mode compatible
+   - Use zod for schema validation
+   - Export types from the module
+5. Do NOT modify unrelated files
+6. Do NOT add unnecessary dependencies
+
+## Completion
+When fully implemented and tested, output: ${COMPLETION_MARKER2}
+`;
+var REVIEW_PROMPT = (proposal, diff, testOutput) => `
+[CODE REVIEW \u2014 EVOLVE IMPLEMENTATION]
+
+## Proposal Implemented
+**Title**: ${proposal.title}
+**Description**: ${proposal.description}
+
+## Changes (git diff)
+\`\`\`diff
+${diff.slice(0, 8000)}
+\`\`\`
+
+## Test Results
+\`\`\`
+${testOutput.slice(0, 2000)}
+\`\`\`
+
+## Review Criteria
+1. **Correctness**: Does the implementation match the proposal?
+2. **Tests**: Are there adequate tests? Do they cover edge cases?
+3. **Code Quality**: Clean, readable, follows existing patterns?
+4. **Regressions**: Could this break existing functionality?
+5. **Security**: No injection vulnerabilities, no unsafe operations?
+
+## Output Format
+Rate each criterion: PASS / WARN / FAIL
+Then overall: APPROVE / APPROVE_WITH_WARNINGS / BLOCK
+
+If BLOCK: explain what must be fixed before merging.
+`;
+function buildContinuationPrompt2(original, iteration) {
+  return `[Evolve Exe \u2014 Iteration ${iteration}]
+
+IMPORTANT:
+- Review your progress so far
+- Continue from where you left off
+- When FULLY complete, output exactly: ${COMPLETION_MARKER2}
+- Do not stop until the task is truly done
+
+Original task:
+${original}`;
+}
+function createEvolveExeTool(ctx, internalSessions, deps = {}) {
+  const maxIterations = deps.evolveExeConfig?.maxIterations ?? DEFAULT_MAX_ITERATIONS2;
+  const iterationTimeoutMs = deps.evolveExeConfig?.iterationTimeoutMs ?? deps.agentTimeoutMs ?? DEFAULT_ITERATION_TIMEOUT_MS2;
+  const configSkipReview = deps.evolveExeConfig?.skipReview ?? false;
+  const configSkipTests = deps.evolveExeConfig?.skipTests ?? false;
+  return tool({
+    description: `Execute evolve proposals autonomously. For each proposal:
+GIT BRANCH \u2192 IMPLEMENT (hephaestus) \u2192 TEST \u2192 BUILD \u2192 REVIEW (momus) \u2192 MERGE/ROLLBACK.
+
+Proposals are identified by their JSONL line number (1-based) from .opencode/evolve-proposals.jsonl.
+Use evolve_scan first to see numbered proposals.
+
+Examples:
+  evolve_exe({ proposals: "1,3" })           \u2014 Execute proposals #1 and #3
+  evolve_exe({ proposals: "all" })            \u2014 Execute all accepted proposals
+  evolve_exe({ proposals: "1", dryRun: true }) \u2014 Preview execution plan only
+  evolve_exe({ proposals: "1,2", publish: true }) \u2014 Execute + auto-publish after`,
+    args: {
+      proposals: tool.schema.string().describe('Proposal numbers: "1,3" or "all" (JSONL line numbers, 1-based)'),
+      dryRun: tool.schema.boolean().optional().describe("Preview plan only, no execution (default: false)"),
+      skipReview: tool.schema.boolean().optional().describe("Skip momus code review (default: false)"),
+      skipTests: tool.schema.boolean().optional().describe("Skip bun test (default: false)"),
+      publish: tool.schema.boolean().optional().describe("Run evolve_publish after all proposals succeed (default: false)")
+    },
+    execute: async (args, toolCtx) => {
+      const cwd = ctx.directory;
+      const dryRun = args.dryRun ?? false;
+      const skipReview = args.skipReview ?? configSkipReview;
+      const skipTests = args.skipTests ?? configSkipTests;
+      toolCtx.metadata({ title: "evolve_exe: reading proposals..." });
+      const { proposals } = readProposalsJsonl(cwd);
+      if (proposals.length === 0) {
+        return "## evolve_exe: No proposals found\n\nRun `evolve_scan` first to generate .opencode/evolve-proposals.jsonl";
+      }
+      const { selected, errors: errors5 } = selectProposals(proposals, args.proposals);
+      if (errors5.length > 0 && selected.length === 0) {
+        return `## evolve_exe: Selection errors
+
+${errors5.map((e) => `- ${e}`).join(`
+`)}`;
+      }
+      if (selected.length === 0) {
+        return `## evolve_exe: No proposals selected
+
+No accepted proposals match the selection.`;
+      }
+      if (dryRun) {
+        const lines2 = [
+          "## evolve_exe: Execution Plan (DRY RUN)",
+          "",
+          `**Selected**: ${selected.length} proposal(s)`,
+          `**Skip tests**: ${skipTests}`,
+          `**Skip review**: ${skipReview}`,
+          `**Auto-publish**: ${args.publish ?? false}`,
+          "",
+          "### Proposals",
+          ""
+        ];
+        for (const p of selected) {
+          lines2.push(`- **#${p.index}** ${p.title} (${p.priority}/${p.effort}, score=${scoreProposal(p)})`);
+          lines2.push(`  Branch: \`evolve/${slugify2(p.title)}\``);
+          if (p.files?.length)
+            lines2.push(`  Files: ${p.files.join(", ")}`);
+        }
+        if (errors5.length > 0) {
+          lines2.push("", "### Warnings", "");
+          for (const e of errors5)
+            lines2.push(`- ${e}`);
+        }
+        return lines2.join(`
+`);
+      }
+      const originalBranch = gitCmd(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+      if (!originalBranch.ok) {
+        return `## evolve_exe: Error
+
+Failed to determine current git branch. Is this a git repository?`;
+      }
+      const results = [];
+      const projectInfo = buildProjectInfo(cwd);
+      for (let i = 0;i < selected.length; i++) {
+        const proposal = selected[i];
+        const result = await executeProposal({
+          ctx,
+          toolCtx,
+          internalSessions,
+          proposal,
+          originalBranch: originalBranch.stdout,
+          cwd,
+          projectInfo,
+          skipTests,
+          skipReview,
+          maxIterations,
+          iterationTimeoutMs,
+          progressLabel: `[${i + 1}/${selected.length}]`
+        });
+        results.push(result);
+      }
+      const successCount = results.filter((r) => r.status === "success").length;
+      const failedCount = results.filter((r) => r.status === "failed").length;
+      const lines = [
+        "## evolve_exe: Execution Complete",
+        "",
+        `**Results**: ${successCount} succeeded, ${failedCount} failed, ${results.length - successCount - failedCount} skipped`,
+        ""
+      ];
+      for (const r of results) {
+        const icon = r.status === "success" ? "PASS" : r.status === "failed" ? "FAIL" : "SKIP";
+        lines.push(`### #${r.index} ${r.title} \u2014 ${icon}`);
+        if (r.branch)
+          lines.push(`- Branch: \`${r.branch}\``);
+        if (r.error)
+          lines.push(`- Error: ${r.error}`);
+        if (r.reviewOutput)
+          lines.push(`- Review: ${r.reviewOutput.slice(0, 500)}`);
+        lines.push("");
+      }
+      if (args.publish && successCount > 0 && failedCount === 0) {
+        lines.push('> All proposals succeeded. Use `evolve_publish({ bump: "patch" })` to publish.');
+      }
+      return lines.join(`
+`);
+    }
+  });
+}
+async function executeProposal(args) {
+  const {
+    ctx,
+    toolCtx,
+    internalSessions,
+    proposal,
+    originalBranch,
+    cwd,
+    projectInfo,
+    skipTests,
+    skipReview,
+    maxIterations,
+    iterationTimeoutMs,
+    progressLabel
+  } = args;
+  const slug = slugify2(proposal.title);
+  const branchName = `evolve/${slug}`;
+  const result = {
+    index: proposal.index,
+    title: proposal.title,
+    status: "failed",
+    branch: branchName
+  };
+  log(`evolve_exe: starting #${proposal.index} "${proposal.title}"`);
+  toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 branching...` });
+  const branchResult = gitCmd(["checkout", "-b", branchName], cwd);
+  if (!branchResult.ok) {
+    result.error = `Failed to create branch: ${branchResult.stderr}`;
+    log("evolve_exe: branch creation failed", { error: branchResult.stderr });
+    return result;
+  }
+  try {
+    toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 implementing...` });
+    const implResult = await runImplementation({
+      ctx,
+      internalSessions,
+      proposal,
+      projectInfo,
+      maxIterations,
+      iterationTimeoutMs,
+      toolCtx,
+      progressLabel
+    });
+    if (!implResult.ok) {
+      result.error = `Implementation failed: ${implResult.error}`;
+      await rollback(cwd, originalBranch, branchName);
+      return result;
+    }
+    if (!skipTests) {
+      toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 testing...` });
+      const testResult = spawnSync2("bun", ["test"], { cwd, encoding: "utf-8", timeout: 120000 });
+      result.testOutput = (testResult.stdout ?? "") + (testResult.stderr ?? "");
+      if (testResult.status !== 0) {
+        result.error = "Tests failed";
+        log("evolve_exe: tests failed", { index: proposal.index });
+        await rollback(cwd, originalBranch, branchName);
+        return result;
+      }
+    }
+    toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 building...` });
+    const buildResult = spawnSync2("bun", ["run", "build"], { cwd, encoding: "utf-8", timeout: 60000 });
+    result.buildOutput = (buildResult.stdout ?? "") + (buildResult.stderr ?? "");
+    if (buildResult.status !== 0) {
+      result.error = "Build failed";
+      log("evolve_exe: build failed", { index: proposal.index });
+      await rollback(cwd, originalBranch, branchName);
+      return result;
+    }
+    if (!skipReview) {
+      toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 reviewing...` });
+      const diff = gitCmd(["diff", `${originalBranch}...HEAD`], cwd);
+      const reviewResult = await runReview({
+        ctx,
+        internalSessions,
+        proposal,
+        diff: diff.stdout,
+        testOutput: result.testOutput ?? "(tests skipped)",
+        iterationTimeoutMs
+      });
+      result.reviewOutput = reviewResult.output;
+      if (reviewResult.blocked) {
+        log("evolve_exe: review BLOCKED", { index: proposal.index });
+      }
+    }
+    toolCtx.metadata({ title: `${progressLabel} #${proposal.index}: ${proposal.title} \u2014 merging...` });
+    gitCmd(["checkout", originalBranch], cwd);
+    const mergeResult = gitCmd(["merge", "--no-ff", branchName, "-m", `evolve: ${proposal.title}`], cwd);
+    if (!mergeResult.ok) {
+      result.error = `Merge failed: ${mergeResult.stderr}`;
+      gitCmd(["merge", "--abort"], cwd);
+      gitCmd(["branch", "-D", branchName], cwd);
+      return result;
+    }
+    gitCmd(["branch", "-d", branchName], cwd);
+    result.status = "success";
+    log(`evolve_exe: #${proposal.index} "${proposal.title}" \u2014 SUCCESS`);
+  } catch (err) {
+    result.error = err instanceof Error ? err.message : String(err);
+    log("evolve_exe: unexpected error", { error: result.error });
+    await rollback(cwd, originalBranch, branchName);
+  }
+  return result;
+}
+async function rollback(cwd, originalBranch, branchName) {
+  gitCmd(["checkout", originalBranch], cwd);
+  gitCmd(["branch", "-D", branchName], cwd);
+  log(`evolve_exe: rolled back branch ${branchName}`);
+}
+async function runImplementation(args) {
+  const { ctx, internalSessions, proposal, projectInfo, maxIterations, iterationTimeoutMs, toolCtx, progressLabel } = args;
+  const sessionResp = await ctx.client.session.create({
+    body: {},
+    query: { directory: ctx.directory }
+  });
+  const sessionID = sessionResp.data?.id;
+  if (!sessionID)
+    return { ok: false, error: "Failed to create implementation session" };
+  internalSessions.add(sessionID);
+  const initialPrompt = IMPLEMENT_PROMPT(proposal, projectInfo);
+  try {
+    for (let i = 0;i < maxIterations; i++) {
+      toolCtx.metadata({
+        title: `${progressLabel} #${proposal.index}: implementing [${i + 1}/${maxIterations}]`
+      });
+      const prompt = i === 0 ? initialPrompt : buildContinuationPrompt2(initialPrompt, i + 1);
+      try {
+        await withTimeout3(ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{ type: "text", text: prompt }],
+            agent: "hephaestus"
+          },
+          query: { directory: ctx.directory }
+        }), iterationTimeoutMs, `evolve_exe implementation iteration ${i + 1}`);
+      } catch (iterError) {
+        const msg = iterError instanceof Error ? iterError.message : String(iterError);
+        if (msg.startsWith("Timeout:")) {
+          log(`evolve_exe: implementation iteration ${i + 1} timed out`);
+          return { ok: false, error: `Implementation timed out at iteration ${i + 1}` };
+        }
+        throw iterError;
+      }
+      const messagesResp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory }
+      });
+      const messages = messagesResp.data ?? [];
+      const lastAssistant = messages.filter((m) => m.info?.role === "assistant").pop();
+      const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`) ?? "";
+      if (rawResult.includes(COMPLETION_MARKER2)) {
+        log(`evolve_exe: implementation completed at iteration ${i + 1}`);
+        return { ok: true };
+      }
+      log(`evolve_exe: implementation iteration ${i + 1}/${maxIterations} \u2014 no completion marker`);
+    }
+    return { ok: false, error: `Max iterations (${maxIterations}) reached without completion` };
+  } finally {
+    internalSessions.delete(sessionID);
+    await ctx.client.session.delete({ path: { id: sessionID }, query: { directory: ctx.directory } }).catch(() => {});
+  }
+}
+async function runReview(args) {
+  const { ctx, internalSessions, proposal, diff, testOutput, iterationTimeoutMs } = args;
+  const sessionResp = await ctx.client.session.create({
+    body: {},
+    query: { directory: ctx.directory }
+  });
+  const sessionID = sessionResp.data?.id;
+  if (!sessionID)
+    return { output: "(Failed to create review session)", blocked: false };
+  internalSessions.add(sessionID);
+  try {
+    const prompt = REVIEW_PROMPT(proposal, diff, testOutput);
+    await withTimeout3(ctx.client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        parts: [{ type: "text", text: prompt }],
+        agent: "momus"
+      },
+      query: { directory: ctx.directory }
+    }), iterationTimeoutMs, "evolve_exe review");
+    const messagesResp = await ctx.client.session.messages({
+      path: { id: sessionID },
+      query: { directory: ctx.directory }
+    });
+    const messages = messagesResp.data ?? [];
+    const lastAssistant = messages.filter((m) => m.info?.role === "assistant").pop();
+    const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`) ?? "(No review output)";
+    const output = sanitizeSpawnResult(rawResult);
+    const blocked = /\bBLOCK\b/i.test(output) && !/\bAPPROVE\b/i.test(output);
+    return { output, blocked };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log("evolve_exe: review error", { error: msg });
+    return { output: `(Review error: ${msg})`, blocked: false };
+  } finally {
+    internalSessions.delete(sessionID);
+    await ctx.client.session.delete({ path: { id: sessionID }, query: { directory: ctx.directory } }).catch(() => {});
+  }
+}
+
+// src/tools/evolve-publish.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import * as fs10 from "fs";
+import * as path10 from "path";
+function run(cmd, args, cwd, timeoutMs = 120000) {
+  const result = spawnSync3(cmd, args, { cwd, encoding: "utf-8", timeout: timeoutMs });
+  return {
+    ok: result.status === 0,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim()
+  };
+}
+function createEvolvePublishTool() {
+  return tool({
+    description: `Publish the plugin: version bump \u2192 test \u2192 build \u2192 npm publish.
+
+Ensures all tests pass and build succeeds before publishing.
+Optionally shows SSH deploy instructions for remote hosts.
+
+Examples:
+  evolve_publish({ bump: "patch" })
+  evolve_publish({ bump: "minor", deploy: "ssh-124" })`,
+    args: {
+      bump: tool.schema.enum(["patch", "minor", "major"]).optional().describe('Version bump type (default: "patch")'),
+      deploy: tool.schema.string().optional().describe("SSH host alias for deploy instructions (e.g. ssh-124)")
+    },
+    execute: async (args) => {
+      const cwd = process.cwd();
+      const bump = args.bump ?? "patch";
+      const lines = [];
+      const gitStatus = run("git", ["status", "--porcelain"], cwd);
+      if (gitStatus.ok && gitStatus.stdout.length > 0) {
+        return `## evolve_publish: Error
+
+Git working directory is not clean. Commit or stash changes before publishing.
+
+\`\`\`
+` + gitStatus.stdout + "\n```";
+      }
+      lines.push("## evolve_publish");
+      lines.push("");
+      const testResult = run("bun", ["test"], cwd);
+      if (!testResult.ok) {
+        lines.push("### Tests FAILED");
+        lines.push("```");
+        lines.push(testResult.stdout.slice(0, 2000));
+        lines.push(testResult.stderr.slice(0, 1000));
+        lines.push("```");
+        lines.push("");
+        lines.push("Fix tests before publishing.");
+        return lines.join(`
+`);
+      }
+      lines.push("- Tests: PASS");
+      const buildResult = run("bun", ["run", "build"], cwd);
+      if (!buildResult.ok) {
+        lines.push("- Build: FAIL");
+        lines.push("```");
+        lines.push(buildResult.stderr.slice(0, 2000));
+        lines.push("```");
+        lines.push("");
+        lines.push("Fix build errors before publishing.");
+        return lines.join(`
+`);
+      }
+      lines.push("- Build: PASS");
+      const bumpResult = run("npm", ["version", bump, "--no-git-tag-version"], cwd);
+      if (!bumpResult.ok) {
+        lines.push(`- Version bump (${bump}): FAIL \u2014 ${bumpResult.stderr}`);
+        return lines.join(`
+`);
+      }
+      const newVersion = bumpResult.stdout.replace(/^v/, "");
+      lines.push(`- Version bump: ${bump} \u2192 ${newVersion}`);
+      const publishResult = run("npm", ["publish"], cwd, 180000);
+      if (!publishResult.ok) {
+        lines.push(`- Publish: FAIL \u2014 ${publishResult.stderr}`);
+        lines.push("");
+        lines.push("Note: Version was bumped locally. You may want to revert package.json if publish failed.");
+        return lines.join(`
+`);
+      }
+      lines.push("- Publish: SUCCESS");
+      let pkgName = "opencode-ultra";
+      try {
+        const pkg = JSON.parse(fs10.readFileSync(path10.join(cwd, "package.json"), "utf-8"));
+        pkgName = pkg.name ?? pkgName;
+      } catch {}
+      lines.push("");
+      lines.push(`Published **${pkgName}@${newVersion}** to npm.`);
+      if (args.deploy) {
+        lines.push("");
+        lines.push("### Deploy Instructions");
+        lines.push("");
+        lines.push(`Run on \`${args.deploy}\`:`);
+        lines.push("```bash");
+        lines.push(`cd ~/.cache/opencode && bun add ${pkgName}@${newVersion}`);
+        lines.push("```");
+      }
+      log("evolve_publish: success", { version: newVersion, bump });
+      return lines.join(`
+`);
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -28838,7 +29707,7 @@ ${unfinished.map((t) => `- [ ] ${t.text}`).join(`
 }
 
 // src/hooks/comment-checker.ts
-import * as fs8 from "fs";
+import * as fs11 from "fs";
 var AI_SLOP_PATTERNS = [
   /\/\/ .{80,}/,
   /\/\/ (This|The|We|Here|Note:)/i,
@@ -28917,7 +29786,7 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
     if (!filePath || !isCodeFile(filePath))
       return;
     try {
-      const content = fs8.readFileSync(filePath, "utf-8");
+      const content = fs11.readFileSync(filePath, "utf-8");
       const result = checkComments(content, filePath, maxRatio, slopThreshold);
       if (result.shouldWarn) {
         output.output += `
@@ -29291,9 +30160,21 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("evolve_apply")) {
     toolRegistry.evolve_apply = evolveApply;
   }
+  if (!disabledTools.has("evolve_scan")) {
+    toolRegistry.evolve_scan = createEvolveScanTool();
+  }
   if (!disabledTools.has("evolve_score")) {
     toolRegistry.evolve_score = createEvolveScoreTool();
   }
+  if (!disabledTools.has("evolve_exe")) {
+    toolRegistry.evolve_exe = createEvolveExeTool(ctx, internalSessions, {
+      agentTimeoutMs: safetyConfig.agentTimeoutMs,
+      evolveExeConfig: pluginConfig.evolve_exe
+    });
+  }
+  if (!disabledTools.has("evolve_publish")) {
+    toolRegistry.evolve_publish = createEvolvePublishTool();
+  }
   return {
     tool: toolRegistry,
     config: async (config3) => {

package/dist/tools/evolve-filter.d.ts

@@ -2,7 +2,10 @@
  * evolve-filter — Pure scoring and filtering logic for evolve proposals.
  *
  * No side effects. All functions are deterministic.
+ * Also exports createEvolveScoreTool() for LLM-facing tool registration.
  */
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
 export interface EvolveProposal {
     title: string;
     priority: "P0" | "P1" | "P2";
@@ -12,6 +15,32 @@ export interface EvolveProposal {
     currentState?: string;
     inspiration?: string;
 }
+/**
+ * JSONL schema for evolve proposals.
+ *
+ * Accepts both canonical keys (description/currentState) and legacy keys
+ * (why/how/current_state) used by older evolve prompts.
+ */
+export declare const EvolveProposalSchema: z.ZodType<EvolveProposal>;
+export type ProposalJsonlValidation = {
+    ok: true;
+    proposal: EvolveProposal;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse and validate a single JSONL line.
+ *
+ * Returns {ok:false,error} for invalid lines so callers can skip with reason.
+ */
+export declare function validateProposalJsonl(line: string): ProposalJsonlValidation;
+/**
+ * Merge existing + incoming proposals, skipping duplicates by normalized title.
+ *
+ * Normalization: lowercase + punctuation/symbol/whitespace removed.
+ */
+export declare function deduplicateProposals(existing: EvolveProposal[], incoming: EvolveProposal[]): EvolveProposal[];
 export interface FilteredProposal extends EvolveProposal {
     score: number;
     accepted: boolean;
@@ -38,3 +67,10 @@ export declare function filterProposals(proposals: EvolveProposal[], config?: Fi
  * ```
  */
 export declare function parseProposalsFromMarkdown(markdown: string): EvolveProposal[];
+/**
+ * Tool: evolve_score
+ *
+ * Takes evolve proposal markdown, parses it, scores each proposal,
+ * and returns a prioritized list. Pure computation, no agent spawning.
+ */
+export declare function createEvolveScoreTool(): ReturnType<typeof tool>;

package/dist/tools/evolve-scan.d.ts

@@ -0,0 +1,7 @@
+/**
+ * evolve_scan — validate + merge + score evolve proposals.
+ *
+ * This tool is scan/report oriented and only writes into `.opencode/`.
+ */
+import { tool } from "@opencode-ai/plugin";
+export declare function createEvolveScanTool(): ReturnType<typeof tool>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.7.7",
+  "version": "0.8.1",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",
@@ -35,6 +35,8 @@
     "@types/bun": "latest",
     "typescript": "^5.8.0"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "license": "MIT"
 }