opencode-ultra 0.6.2 → 0.6.4

package/dist/index.js

@@ -14831,11 +14831,11 @@ var KEYWORD_DEFS = [
   { pattern: SEARCH_PATTERN, type: "search", getMessage: () => SEARCH_MESSAGE },
   { pattern: ANALYZE_PATTERN, type: "analyze", getMessage: () => ANALYZE_MESSAGE },
   { pattern: THINK_PATTERN, type: "think", getMessage: () => THINK_MESSAGE },
-  { pattern: EVOLVE_PATTERN, type: "evolve", getMessage: () => EVOLVE_MESSAGE }
+  { pattern: EVOLVE_PATTERN, type: "evolve", getMessage: (ctx) => buildEvolveMessage(ctx) }
 ];
-function detectKeywords(text) {
+function detectKeywords(text, evolveCtx) {
   const clean = removeCodeBlocks(text);
-  return KEYWORD_DEFS.filter(({ pattern }) => pattern.test(clean)).map(({ type, getMessage }) => ({ type, message: getMessage() }));
+  return KEYWORD_DEFS.filter(({ pattern }) => pattern.test(clean)).map(({ type, getMessage }) => ({ type, message: getMessage(evolveCtx) }));
 }
 var ULTRAWORK_MESSAGE = `<ultrawork-mode>
 
@@ -14921,84 +14921,95 @@ IF COMPLEX \u2014 DO NOT STRUGGLE ALONE. Consult specialists:
 
 SYNTHESIZE findings before proceeding.`;
 var THINK_MESSAGE = `Extended thinking enabled. Take your time to reason thoroughly.`;
-var EVOLVE_MESSAGE = `[evolve-mode] SELF-IMPROVEMENT CYCLE ACTIVATED.
+function buildEvolveMessage(ctx) {
+  const inventory = ctx ? buildSelfInventory(ctx) : "(No capability data available \u2014 read source manually)";
+  return `[evolve-mode] SELF-IMPROVEMENT CYCLE ACTIVATED.
 
 ## MISSION
-Discover what other OpenCode plugins do well, compare with opencode-ultra's current capabilities, and propose concrete improvements to opencode-ultra itself.
-
+Compare opencode-ultra's current capabilities with other OpenCode plugins, then propose concrete improvements.
 This is NOT about installing other plugins. This is about LEARNING from the ecosystem and making opencode-ultra better.
 
-## TOOLS AVAILABLE
-- **spawn_agent** \u2014 run scout + explore agents in parallel for data gathering
-- **ledger_save** \u2014 persist improvement proposals for future implementation
+## opencode-ultra CURRENT CAPABILITIES (auto-generated from source)
+${inventory}
 
-## PHASE 1: GATHER (parallel \u2014 BOTH agents MANDATORY)
+You already have the full capability list above. Do NOT try to read opencode-ultra source files \u2014 this inventory IS the source of truth.
 
-You MUST spawn BOTH agents below. Do NOT skip the explore agent.
+## PHASE 1: ECOSYSTEM RESEARCH (spawn_agent)
 
+Research what other plugins offer:
 \`\`\`
 spawn_agent({
   agents: [
-    {agent: "scout", prompt: "Search npm and GitHub for OpenCode 1.2.x plugins. For EACH plugin, analyze: what features does it provide? What hooks, tools, or techniques does it use? Focus on UNIQUE capabilities that are genuinely useful. Return a structured feature inventory per plugin.", description: "Ecosystem feature scan"},
-    {agent: "explore", prompt: "Read opencode-ultra's INSTALLED source at ~/.cache/opencode/node_modules/opencode-ultra/. Read these files: src/index.ts, src/tools/spawn-agent.ts, src/tools/ralph-loop.ts, src/tools/evolve-apply.ts, src/hooks/keyword-detector.ts, src/hooks/rules-injector.ts, src/safety/sanitizer.ts, src/safety/trust-score.ts, src/concurrency/pool.ts, src/agents/index.ts, src/categories/index.ts, README.md. For EACH file, list: what it does, what hooks/tools/features it provides, what techniques it uses. Output a structured capability inventory with Yes/No for each feature area.", description: "Self-analysis of opencode-ultra"}
+    {agent: "scout", prompt: "Search npm and GitHub for OpenCode 1.2.x plugins. For EACH interesting plugin: what features does it provide? What hooks, tools, or techniques does it use? Focus on UNIQUE capabilities. Return a structured feature inventory per plugin.", description: "Ecosystem scan"},
+    {agent: "librarian", prompt: "Search for OpenCode plugin best practices, architectural patterns, and advanced techniques. Look at oh-my-opencode, opencode-supermemory, opencode-dcp, opencode-rate-limit-fallback, opencode-worktree, opencode-mad. What patterns do they share? What's unique?", description: "Plugin patterns research"}
   ]
 })
 \`\`\`
 
-## HARD GATE: DO NOT proceed to Phase 2 until BOTH agents return results.
-If the explore agent fails to find files, try reading from the current project directory or use Grep to locate opencode-ultra source files. You MUST have a concrete list of opencode-ultra's current capabilities before comparing.
-
 ## PHASE 2: COMPARE
 
-Build a structured gap analysis using BOTH agents' results.
-
-**CRITICAL**: The "opencode-ultra" column MUST be filled with Yes/No/Partial based on the explore agent's output. NEVER write "TBD" or "unknown" \u2014 if you don't know, re-read the source.
+Build a Feature Matrix using the capability list above and agent results.
 
-### Feature Matrix
-| Feature | opencode-ultra (current) | Other plugin(s) | Gap? |
-|---------|-------------------------|-----------------|------|
-| (feature) | Yes / No / Partial \u2014 cite which file | Which plugin has it | Missing / Partial / Covered |
+**RULE**: The "opencode-ultra" column MUST be Yes/No/Partial based on the inventory above. NEVER write "TBD", "unknown", or "\u4E0D\u660E".
 
-Focus on features that are:
-- **Genuinely useful** (not gimmicks)
-- **Feasible to implement** (not requiring external infrastructure)
-- **Complementary** to existing capabilities (not duplicate)
+| Feature | opencode-ultra | Other plugin(s) | Gap? |
+|---------|---------------|-----------------|------|
+| (feature) | Yes \u2014 (tool/hook name) | Which plugin | Covered / Missing / Partial |
 
-### What to IGNORE
-- Auth plugins (opencode-antigravity-auth etc.) \u2014 domain-specific, not relevant
-- oh-my-opencode features we already ported \u2014 mark as "Covered"
-- Trivial wrappers or abandoned projects
+Focus on genuinely useful, feasible, complementary features.
 
 ## PHASE 3: PROPOSE
-For each identified gap (Missing or Partial), produce a concrete improvement proposal:
 
-\`\`\`
+For each Missing or Partial gap:
+
 ## Improvement: [Feature Name]
 **Inspiration**: [Plugin name] \u2014 [what it does]
-**Current state in opencode-ultra**: [what we have now, citing files]
-**Why**: [Why opencode-ultra needs this]
-**How**: [Implementation sketch \u2014 which file to modify, what to add]
+**Current state**: [what opencode-ultra has now from the inventory]
+**Why**: [concrete benefit]
+**How**: [which file to modify, what to add]
 **Effort**: Low / Medium / High
-**Priority**: P0 (critical) / P1 (important) / P2 (nice-to-have)
-\`\`\`
+**Priority**: P0 / P1 / P2
 
-Sort proposals by Priority then Effort (P0-Low first, P2-High last).
+Sort by Priority then Effort.
 
 ## PHASE 4: SAVE
-Save the full analysis to the continuity ledger:
 \`\`\`
 ledger_save({
   name: "evolve-scan-YYYY-MM-DD",
-  content: "# Evolve Scan Results\\n\\n## Feature Matrix\\n...\\n## Improvement Proposals\\n..."
+  content: "# Evolve Scan Results\\n\\n## Feature Matrix\\n...\\n## Proposals\\n..."
 })
 \`\`\`
 
-## IMPORTANT
-- The goal is to make opencode-ultra BETTER, not to install other plugins.
-- Other plugins are REFERENCE MATERIAL \u2014 study their approach, then design our own implementation.
-- Every proposal must include a concrete "How" section with file paths and implementation direction.
-- The opencode-ultra column in Feature Matrix must NEVER be TBD. Read the source first.
-- Present the final proposals to the user for approval before any implementation.`;
+## 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".
+- Present proposals to user for approval before implementation.`;
+}
+function buildSelfInventory(ctx) {
+  const lines = [];
+  lines.push("### Tools");
+  for (const t of ctx.tools) {
+    lines.push(`- ${t}`);
+  }
+  lines.push("");
+  lines.push("### Hooks");
+  for (const h of ctx.hooks) {
+    lines.push(`- ${h}`);
+  }
+  lines.push("");
+  lines.push("### Agents");
+  for (const [name, def] of Object.entries(ctx.agents)) {
+    const shortModel = def.model.split("/").pop() ?? def.model;
+    lines.push(`- **${name}** (${shortModel}) \u2014 ${def.description}`);
+  }
+  lines.push("");
+  lines.push("### Additional Features");
+  for (const f of ctx.features) {
+    lines.push(`- ${f}`);
+  }
+  return lines.join(`
+`);
+}
 
 // src/hooks/rules-injector.ts
 import * as fs2 from "fs";
@@ -29076,7 +29087,31 @@ var OpenCodeUltra = async (ctx) => {
       }
       if (!disabledHooks.has("keyword-detector")) {
         const promptText = extractPromptText(output.parts);
-        const detected = detectKeywords(promptText);
+        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 detected = detectKeywords(promptText, evolveCtx);
         if (detected.length > 0) {
           const hasUltrawork = detected.some((k) => k.type === "ultrawork");
           if (hasUltrawork) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",