opencode-ultra 0.7.0 → 0.7.1

package/dist/config.d.ts

@@ -73,6 +73,11 @@ declare const PluginConfigSchema: z.ZodObject<{
         maxTotalSpawned: z.ZodOptional<z.ZodNumber>;
         agentTimeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    evolve_auto: z.ZodOptional<z.ZodObject<{
+        minScore: z.ZodOptional<z.ZodNumber>;
+        maxProposals: z.ZodOptional<z.ZodNumber>;
+        skipReview: 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/hooks/keyword-detector.d.ts

@@ -7,4 +7,14 @@ export declare function extractPromptText(parts: Array<{
     type: string;
     text?: string;
 }>): string;
-export declare function detectKeywords(text: string): DetectedKeyword[];
+/** Context for generating dynamic evolve message */
+export interface EvolveContext {
+    agents: Record<string, {
+        model: string;
+        description: string;
+    }>;
+    tools: string[];
+    hooks: string[];
+    features: string[];
+}
+export declare function detectKeywords(text: string, evolveCtx?: EvolveContext): DetectedKeyword[];

package/dist/index.js

@@ -9,6 +9,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = import.meta.require;
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -14472,6 +14473,11 @@ 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_auto: exports_external.object({
+    minScore: exports_external.number().min(0).max(30).optional(),
+    maxProposals: exports_external.number().min(1).max(10).optional(),
+    skipReview: 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_auto: override.evolve_auto ?? base.evolve_auto
   };
 }
 function detectConfigFile(basePath) {
@@ -14980,6 +14987,15 @@ ledger_save({
 })
 \`\`\`
 
+## AUTOMATED MODE
+
+The \`evolve_auto\` tool is available for autonomous execution:
+- \`evolve_auto({dryRun: true})\` \u2014 Scan + filter only (preview proposals with scores)
+- \`evolve_auto({})\` \u2014 Full autonomous cycle (scan \u2192 filter \u2192 implement \u2192 review \u2192 save)
+
+Use \`evolve_auto\` when the user requests autonomous self-improvement.
+Manual exploration (the phases above) is still the default for human-guided evolve.
+
 ## RULES
 - Use the capability inventory above as ground truth. No file reading needed.
 - Proposals must cite specific tools/hooks from the inventory for "Current state".
@@ -28600,6 +28616,388 @@ function formatResult(result) {
 `);
 }
 
+// src/tools/evolve-filter.ts
+var PRIORITY_WEIGHT = {
+  P0: 10,
+  P1: 5,
+  P2: 1
+};
+var EFFORT_WEIGHT = {
+  Low: 3,
+  Medium: 2,
+  High: 1
+};
+var DEFAULT_MIN_SCORE = 5;
+var DEFAULT_MAX_PROPOSALS = 3;
+function scoreProposal(p) {
+  const pw = PRIORITY_WEIGHT[p.priority] ?? 1;
+  const ew = EFFORT_WEIGHT[p.effort] ?? 1;
+  return pw * ew;
+}
+function filterProposals(proposals, config3) {
+  const minScore = config3?.minScore ?? DEFAULT_MIN_SCORE;
+  const maxProposals = config3?.maxProposals ?? DEFAULT_MAX_PROPOSALS;
+  const scored = proposals.map((p) => {
+    const score = scoreProposal(p);
+    const accepted2 = score >= minScore;
+    return {
+      ...p,
+      score,
+      accepted: accepted2,
+      reason: accepted2 ? undefined : `Score ${score} below threshold ${minScore}`
+    };
+  });
+  const accepted = scored.filter((p) => p.accepted).sort((a, b) => b.score - a.score).slice(0, maxProposals);
+  const rejected = scored.filter((p) => !p.accepted);
+  const acceptedSet = new Set(accepted);
+  const overflow = scored.filter((p) => p.accepted && !acceptedSet.has(p)).map((p) => ({ ...p, accepted: false, reason: `Exceeded maxProposals (${maxProposals})` }));
+  return [...accepted, ...overflow, ...rejected];
+}
+function parseProposalsFromMarkdown(markdown) {
+  const proposals = [];
+  const sections = markdown.split(/^##\s+Improvement:\s*/m);
+  for (let i = 1;i < sections.length; i++) {
+    const section = sections[i];
+    const lines = section.trim();
+    const titleMatch = lines.match(/^(.+?)(?:\n|$)/);
+    const title = titleMatch?.[1]?.trim() ?? "Untitled";
+    const priority = extractField(lines, "Priority");
+    const effort = extractField(lines, "Effort");
+    const description = extractField(lines, "Why") || extractField(lines, "How") || "";
+    const currentState = extractField(lines, "Current state") || undefined;
+    const inspiration = extractField(lines, "Inspiration") || undefined;
+    const normalizedPriority = normalizePriority(priority);
+    const normalizedEffort = normalizeEffort(effort);
+    if (normalizedPriority && normalizedEffort) {
+      proposals.push({
+        title,
+        priority: normalizedPriority,
+        effort: normalizedEffort,
+        description,
+        currentState,
+        inspiration
+      });
+    }
+  }
+  return proposals;
+}
+function extractField(text, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}\\*\\*\\s*:\\s*(.+?)(?:\\n|$)`, "i");
+  const match = text.match(pattern);
+  return match?.[1]?.trim() ?? "";
+}
+function normalizePriority(raw) {
+  const upper = raw.toUpperCase().trim();
+  if (upper.startsWith("P0"))
+    return "P0";
+  if (upper.startsWith("P1"))
+    return "P1";
+  if (upper.startsWith("P2"))
+    return "P2";
+  return null;
+}
+function normalizeEffort(raw) {
+  const lower = raw.toLowerCase().trim();
+  if (lower.startsWith("low"))
+    return "Low";
+  if (lower.startsWith("medium") || lower.startsWith("med"))
+    return "Medium";
+  if (lower.startsWith("high"))
+    return "High";
+  return null;
+}
+
+// src/tools/evolve-auto.ts
+var DEFAULT_AGENT_TIMEOUT_MS2 = 300000;
+var DEFAULT_MAX_SPAWNED = 15;
+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);
+  }
+}
+async function runEphemeralAgent(ctx, agentName, prompt, internalSessions, timeoutMs) {
+  const sessionResp = await ctx.client.session.create({
+    body: {},
+    query: { directory: ctx.directory }
+  });
+  const sessionID = sessionResp.data?.id;
+  if (!sessionID)
+    throw new Error("Failed to create session");
+  internalSessions.add(sessionID);
+  try {
+    await withTimeout3(ctx.client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        parts: [{ type: "text", text: prompt }],
+        agent: agentName
+      },
+      query: { directory: ctx.directory }
+    }), timeoutMs, `${agentName}`);
+    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 response)";
+    return sanitizeSpawnResult(rawResult);
+  } finally {
+    internalSessions.delete(sessionID);
+    await ctx.client.session.delete({ path: { id: sessionID }, query: { directory: ctx.directory } }).catch(() => {});
+  }
+}
+function buildEvolvePrompt(evolveCtx) {
+  const inventory = evolveCtx ? buildInventorySection(evolveCtx) : "(No capability data)";
+  return `You are performing an automated self-improvement scan for the opencode-ultra plugin.
+
+## Current Capabilities
+${inventory}
+
+## Task
+1. Research the OpenCode plugin ecosystem (npm, GitHub) for features that opencode-ultra lacks
+2. Compare capabilities and identify gaps
+3. Propose concrete improvements in this EXACT format for EACH proposal:
+
+## Improvement: [Feature Name]
+**Inspiration**: [Plugin name] \u2014 [what it does]
+**Current state**: [what opencode-ultra has now]
+**Why**: [concrete benefit]
+**How**: [which file to modify, what to add]
+**Effort**: Low / Medium / High
+**Priority**: P0 / P1 / P2
+
+Sort by Priority then Effort. Be specific and actionable.`;
+}
+function buildInventorySection(ctx) {
+  const lines = [];
+  lines.push("### Tools: " + ctx.tools.join(", "));
+  lines.push("### Hooks: " + ctx.hooks.join(", "));
+  lines.push("### Agents");
+  for (const [name, def] of Object.entries(ctx.agents)) {
+    lines.push(`- ${name} (${def.model}) \u2014 ${def.description}`);
+  }
+  lines.push("### Features: " + ctx.features.join(", "));
+  return lines.join(`
+`);
+}
+function buildImplementPrompt(proposal) {
+  return `Implement the following improvement for opencode-ultra:
+
+## ${proposal.title}
+- **Priority**: ${proposal.priority}
+- **Effort**: ${proposal.effort}
+- **Description**: ${proposal.description}
+${proposal.currentState ? `- **Current state**: ${proposal.currentState}` : ""}
+${proposal.inspiration ? `- **Inspiration**: ${proposal.inspiration}` : ""}
+${proposal.files ? `- **Files to modify**: ${proposal.files.join(", ")}` : ""}
+
+Implement this change. Be precise and minimal. Only modify what is necessary.`;
+}
+function buildReviewPrompt(implementations) {
+  return `Review the following implementation results from an automated evolve cycle:
+
+${implementations.map((impl, i) => `### Implementation ${i + 1}
+${impl}`).join(`
+
+---
+
+`)}
+
+Check for:
+1. Breaking changes
+2. Missing imports or type errors
+3. Logic bugs
+4. Security concerns
+5. Inconsistencies with existing code patterns
+
+Report any blocking issues. If everything looks good, confirm with "LGTM".`;
+}
+function formatFinalReport(result) {
+  const lines = [];
+  lines.push("# Evolve Auto Results");
+  lines.push("");
+  if (result.proposals) {
+    const accepted = result.proposals.filter((p) => p.accepted);
+    const rejected = result.proposals.filter((p) => !p.accepted);
+    lines.push("## Proposals");
+    lines.push("");
+    if (accepted.length > 0) {
+      lines.push("### Accepted");
+      for (const p of accepted) {
+        lines.push(`- **${p.title}** [${p.priority}/${p.effort}] score=${p.score}`);
+      }
+      lines.push("");
+    }
+    if (rejected.length > 0) {
+      lines.push("### Rejected");
+      for (const p of rejected) {
+        lines.push(`- **${p.title}** [${p.priority}/${p.effort}] score=${p.score} \u2014 ${p.reason}`);
+      }
+      lines.push("");
+    }
+  }
+  if (result.implementations && result.implementations.length > 0) {
+    lines.push("## Implementations");
+    lines.push("");
+    for (let i = 0;i < result.implementations.length; i++) {
+      lines.push(`### Implementation ${i + 1}`);
+      lines.push(result.implementations[i]);
+      lines.push("");
+    }
+  }
+  if (result.reviewOutput) {
+    lines.push("## Review");
+    lines.push(result.reviewOutput);
+    lines.push("");
+  }
+  if (result.savedKey) {
+    lines.push(`## Saved as \`${result.savedKey}\``);
+  }
+  return lines.join(`
+`);
+}
+function createEvolveAutoTool(ctx, internalSessions, deps) {
+  const timeoutMs = deps.agentTimeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS2;
+  return tool({
+    description: `Autonomous self-improvement cycle for opencode-ultra.
+
+Runs a 5-phase loop: SCAN \u2192 FILTER \u2192 IMPLEMENT \u2192 REVIEW \u2192 SAVE
+
+Phases:
+1. SCAN \u2014 Sisyphus scans ecosystem and proposes improvements
+2. FILTER \u2014 Score and filter proposals by priority \xD7 effort
+3. IMPLEMENT \u2014 Hephaestus implements each accepted proposal sequentially
+4. REVIEW \u2014 Momus reviews all implementations
+5. SAVE \u2014 Results saved to continuity ledger
+
+Use dryRun: true to run SCAN + FILTER only (preview proposals without implementing).`,
+    args: {
+      dryRun: tool.schema.boolean().optional().describe("SCAN+FILTER only, no implementation (default: false)"),
+      maxProposals: tool.schema.number().optional().describe("Max proposals to implement per cycle (default: 3)"),
+      minScore: tool.schema.number().optional().describe("Minimum score threshold (default: 5)"),
+      skipReview: tool.schema.boolean().optional().describe("Skip momus review phase (default: false)")
+    },
+    execute: async (args, toolCtx) => {
+      const dryRun = args.dryRun ?? false;
+      const minScore = args.minScore ?? deps.evolveAutoConfig?.minScore ?? 5;
+      const maxProposals = args.maxProposals ?? deps.evolveAutoConfig?.maxProposals ?? 3;
+      const skipReview = args.skipReview ?? deps.evolveAutoConfig?.skipReview ?? false;
+      const result = { phase: "INIT" };
+      if (internalSessions.size >= DEFAULT_MAX_SPAWNED - 1) {
+        return "Error: Too many concurrent sessions. Wait for active sessions to complete.";
+      }
+      result.phase = "SCAN";
+      toolCtx.metadata({ title: "evolve_auto: SCAN \u2014 scanning ecosystem..." });
+      log("evolve_auto: Phase 1 SCAN starting");
+      let scanOutput;
+      try {
+        scanOutput = await runEphemeralAgent(ctx, "sisyphus", buildEvolvePrompt(deps.evolveCtx), internalSessions, timeoutMs);
+        result.scanOutput = scanOutput;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log("evolve_auto: SCAN failed", { error: msg });
+        return `## evolve_auto: SCAN Failed
+
+**Error**: ${msg}`;
+      }
+      result.phase = "FILTER";
+      toolCtx.metadata({ title: "evolve_auto: FILTER \u2014 scoring proposals..." });
+      log("evolve_auto: Phase 2 PARSE+FILTER");
+      const parsed = parseProposalsFromMarkdown(scanOutput);
+      if (parsed.length === 0) {
+        log("evolve_auto: no proposals parsed from scan output");
+        return `## evolve_auto: No Proposals
+
+Sisyphus scan completed but no improvement proposals were found in the output.
+
+### Raw Scan Output
+${scanOutput}`;
+      }
+      const filtered = filterProposals(parsed, { minScore, maxProposals });
+      result.proposals = filtered;
+      const accepted = filtered.filter((p) => p.accepted);
+      log("evolve_auto: filtered", {
+        total: parsed.length,
+        accepted: accepted.length,
+        rejected: filtered.length - accepted.length
+      });
+      if (accepted.length === 0) {
+        return `## evolve_auto: All Proposals Rejected
+
+Parsed ${parsed.length} proposals, but none met the threshold (minScore=${minScore}).
+
+${formatFinalReport(result)}`;
+      }
+      if (dryRun) {
+        toolCtx.metadata({ title: `evolve_auto: DRY RUN \u2014 ${accepted.length} proposals accepted` });
+        return `## evolve_auto: Dry Run Complete
+
+${formatFinalReport(result)}
+
+> Use \`evolve_auto({})\` for full execution.`;
+      }
+      result.phase = "IMPLEMENT";
+      result.implementations = [];
+      log("evolve_auto: Phase 3 IMPLEMENT", { count: accepted.length });
+      for (let i = 0;i < accepted.length; i++) {
+        const proposal = accepted[i];
+        toolCtx.metadata({
+          title: `evolve_auto: IMPLEMENT [${i + 1}/${accepted.length}] \u2014 ${proposal.title}`
+        });
+        try {
+          const implResult = await runEphemeralAgent(ctx, "hephaestus", buildImplementPrompt(proposal), internalSessions, timeoutMs);
+          result.implementations.push(implResult);
+          log(`evolve_auto: implemented ${i + 1}/${accepted.length}`, { title: proposal.title });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log(`evolve_auto: IMPLEMENT failed for "${proposal.title}"`, { error: msg });
+          result.implementations.push(`**FAILED**: ${proposal.title} \u2014 ${msg}`);
+          break;
+        }
+      }
+      if (!skipReview && result.implementations.length > 0) {
+        result.phase = "REVIEW";
+        toolCtx.metadata({ title: "evolve_auto: REVIEW \u2014 momus reviewing..." });
+        log("evolve_auto: Phase 4 REVIEW");
+        try {
+          const reviewResult = await runEphemeralAgent(ctx, "momus", buildReviewPrompt(result.implementations), internalSessions, timeoutMs);
+          result.reviewOutput = reviewResult;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          log("evolve_auto: REVIEW failed", { error: msg });
+          result.reviewOutput = `Review failed: ${msg}`;
+        }
+      }
+      result.phase = "SAVE";
+      toolCtx.metadata({ title: "evolve_auto: SAVE \u2014 saving results..." });
+      log("evolve_auto: Phase 5 SAVE");
+      const dateStr = new Date().toISOString().slice(0, 10);
+      const savedKey = `evolve-auto-${dateStr}`;
+      result.savedKey = savedKey;
+      const report = formatFinalReport(result);
+      const fs8 = await import("fs");
+      const path8 = await import("path");
+      const ledgerDir2 = path8.join(ctx.directory, ".opencode", "ledgers");
+      try {
+        await fs8.promises.mkdir(ledgerDir2, { recursive: true });
+        await fs8.promises.writeFile(path8.join(ledgerDir2, `${savedKey}.md`), report, "utf-8");
+        log("evolve_auto: saved to ledger", { key: savedKey });
+      } catch (err) {
+        log("evolve_auto: failed to save ledger", { error: String(err) });
+      }
+      toolCtx.metadata({ title: `evolve_auto: DONE \u2014 ${accepted.length} improvements` });
+      return report;
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -29070,6 +29468,30 @@ var OpenCodeUltra = async (ctx) => {
   const astGrepBin = findAstGrepBinary();
   const astSearch = astGrepBin ? createAstSearchTool(ctx, astGrepBin) : null;
   const evolveApply = createEvolveApplyTool(ctx);
+  const buildEvolveCtx = (toolNames) => ({
+    agents: Object.fromEntries(Object.entries(agents).map(([name, def]) => [name, { model: def.model, description: def.description }])),
+    tools: toolNames,
+    hooks: [
+      ...!disabledHooks.has("keyword-detector") ? ["keyword-detector (ultrawork/search/analyze/think/evolve detection)"] : [],
+      ...!disabledHooks.has("rules-injector") ? ["rules-injector (architecture.md/codestyle.md/rules.md injection)"] : [],
+      ...!disabledHooks.has("fragment-injector") ? ["fragment-injector (conditional context fragments)"] : [],
+      ...!disabledHooks.has("prompt-renderer") ? ["prompt-renderer (template-based prompt rendering)"] : [],
+      ...!disabledHooks.has("todo-enforcer") ? ["todo-enforcer (force completion of unfinished TODOs)"] : [],
+      ...!disabledHooks.has("comment-checker") ? ["comment-checker (detect AI slop comments in code)"] : [],
+      ...!disabledHooks.has("token-truncation") ? ["token-truncation (auto-truncate large tool outputs)"] : [],
+      ...!disabledHooks.has("session-compaction") ? ["session-compaction (auto-compact long sessions)"] : []
+    ],
+    features: [
+      pool ? "concurrency control (semaphore-based per-provider/model limits)" : "no concurrency limits",
+      "prompt injection sanitizer (17 patterns, 6 categories)",
+      "trust score system (5-factor npm package evaluation)",
+      "spawn limit (max concurrent sub-agents)",
+      "agent timeout (per-agent execution timeout)",
+      pluginConfig.categories ? "categories (model/variant routing per task type)" : "no categories configured",
+      "continuity ledger (persistent key-value store across sessions)",
+      "multi-language keyword detection (EN/JP/CN)"
+    ]
+  });
   const todoEnforcer = createTodoEnforcer(ctx, internalSessions, pluginConfig.todo_enforcer?.maxEnforcements);
   const commentCheckerHook = createCommentCheckerHook(internalSessions, pluginConfig.comment_checker?.maxRatio, pluginConfig.comment_checker?.slopThreshold);
   const tokenTruncationHook = createTokenTruncationHook(internalSessions, pluginConfig.token_truncation?.maxChars);
@@ -29111,6 +29533,14 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("evolve_apply")) {
     toolRegistry.evolve_apply = evolveApply;
   }
+  if (!disabledTools.has("evolve_auto")) {
+    const evolveAuto = createEvolveAutoTool(ctx, internalSessions, {
+      agentTimeoutMs: safetyConfig.agentTimeoutMs,
+      evolveCtx: buildEvolveCtx(Object.keys(toolRegistry)),
+      evolveAutoConfig: pluginConfig.evolve_auto
+    });
+    toolRegistry.evolve_auto = evolveAuto;
+  }
   return {
     tool: toolRegistry,
     config: async (config3) => {
@@ -29152,30 +29582,7 @@ var OpenCodeUltra = async (ctx) => {
       }
       if (!disabledHooks.has("keyword-detector")) {
         const promptText = extractPromptText(output.parts);
-        const evolveCtx = {
-          agents: Object.fromEntries(Object.entries(agents).map(([name, def]) => [name, { model: def.model, description: def.description }])),
-          tools: Object.keys(toolRegistry),
-          hooks: [
-            ...!disabledHooks.has("keyword-detector") ? ["keyword-detector (ultrawork/search/analyze/think/evolve detection)"] : [],
-            ...!disabledHooks.has("rules-injector") ? ["rules-injector (architecture.md/codestyle.md/rules.md injection)"] : [],
-            ...!disabledHooks.has("fragment-injector") ? ["fragment-injector (conditional context fragments)"] : [],
-            ...!disabledHooks.has("prompt-renderer") ? ["prompt-renderer (template-based prompt rendering)"] : [],
-            ...!disabledHooks.has("todo-enforcer") ? ["todo-enforcer (force completion of unfinished TODOs)"] : [],
-            ...!disabledHooks.has("comment-checker") ? ["comment-checker (detect AI slop comments in code)"] : [],
-            ...!disabledHooks.has("token-truncation") ? ["token-truncation (auto-truncate large tool outputs)"] : [],
-            ...!disabledHooks.has("session-compaction") ? ["session-compaction (auto-compact long sessions)"] : []
-          ],
-          features: [
-            pool ? "concurrency control (semaphore-based per-provider/model limits)" : "no concurrency limits",
-            "prompt injection sanitizer (17 patterns, 6 categories)",
-            "trust score system (5-factor npm package evaluation)",
-            "spawn limit (max concurrent sub-agents)",
-            "agent timeout (per-agent execution timeout)",
-            pluginConfig.categories ? "categories (model/variant routing per task type)" : "no categories configured",
-            "continuity ledger (persistent key-value store across sessions)",
-            "multi-language keyword detection (EN/JP/CN)"
-          ]
-        };
+        const evolveCtx = buildEvolveCtx(Object.keys(toolRegistry));
         const detected = detectKeywords(promptText, evolveCtx);
         if (detected.length > 0) {
           const hasUltrawork = detected.some((k) => k.type === "ultrawork");

package/dist/safety/index.d.ts

@@ -1,2 +1,2 @@
 export { sanitizeAgentOutput, sanitizeSpawnResult, type SanitizeResult } from "./sanitizer";
-export { computeTrustScore, isTyposquatSuspect, formatTrustTable, type PackageMetadata, type TrustScoreResult, type TrustFactor, } from "./trust-score";
+export { computeTrustScore, isTyposquatSuspect, isHighPrivilege, formatTrustTable, MAX_TRUST_SCORE, type PackageMetadata, type TrustScoreResult, type TrustFactor, } from "./trust-score";

package/dist/safety/trust-score.d.ts

@@ -2,17 +2,21 @@
  * Trust Score — evaluates npm packages for reliability and safety.
  * Used by evolve mode to rank plugin recommendations.
  *
- * Score 0–100:
- *   90–100  HIGH trust (well-maintained, popular, verified)
- *   70–89   MEDIUM trust (decent maintenance, some usage)
- *   40–69   LOW trust (stale, low usage, or missing metadata)
- *   0–39    RISKY (abandoned, typosquat suspect, no repo)
+ * Factors (max 108):
+ *   recency (25), popularity (25), quality (20), repository (15),
+ *   safety (15), provenance (8), dependency_risk (0 or -5 penalty)
+ *
+ * Levels (by percentage of 108):
+ *   90%+ HIGH | 70-89% MEDIUM | 40-69% LOW | <40% RISKY
  */
+export declare const MAX_TRUST_SCORE = 108;
 export interface PackageMetadata {
     name: string;
     version?: string;
     description?: string;
     license?: string;
+    /** Whether npm provenance/attestation is available */
+    hasProvenance?: boolean;
     /** ISO date string of last publish */
     lastPublished?: string;
     /** Weekly npm downloads */
@@ -42,6 +46,8 @@ export interface TrustFactor {
 }
 export declare function computeTrustScore(meta: PackageMetadata): TrustScoreResult;
 export declare function isTyposquatSuspect(name: string): boolean;
+/** Check if package name suggests high-privilege access (PTY, exec, shell, sudo) */
+export declare function isHighPrivilege(name: string): boolean;
 /**
  * Format trust scores as a markdown table for evolve output.
  */

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

@@ -0,0 +1,40 @@
+/**
+ * evolve-filter — Pure scoring and filtering logic for evolve proposals.
+ *
+ * No side effects. All functions are deterministic.
+ */
+export interface EvolveProposal {
+    title: string;
+    priority: "P0" | "P1" | "P2";
+    effort: "Low" | "Medium" | "High";
+    description: string;
+    files?: string[];
+    currentState?: string;
+    inspiration?: string;
+}
+export interface FilteredProposal extends EvolveProposal {
+    score: number;
+    accepted: boolean;
+    reason?: string;
+}
+export interface FilterConfig {
+    minScore?: number;
+    maxProposals?: number;
+}
+export declare function scoreProposal(p: EvolveProposal): number;
+export declare function filterProposals(proposals: EvolveProposal[], config?: FilterConfig): FilteredProposal[];
+/**
+ * Parse Sisyphus evolve output into structured proposals.
+ *
+ * Expected format (from keyword-detector EVOLVE_MESSAGE Phase 3):
+ * ```
+ * ## Improvement: [Feature Name]
+ * **Inspiration**: [Plugin name] — [what it does]
+ * **Current state**: [what opencode-ultra has now]
+ * **Why**: [concrete benefit]
+ * **How**: [which file to modify, what to add]
+ * **Effort**: Low / Medium / High
+ * **Priority**: P0 / P1 / P2
+ * ```
+ */
+export declare function parseProposalsFromMarkdown(markdown: string): EvolveProposal[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",