opencode-ultra 0.2.1 → 0.3.0

package/dist/config.d.ts

@@ -38,6 +38,10 @@ declare const PluginConfigSchema: z.ZodObject<{
     disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    token_truncation: z.ZodOptional<z.ZodObject<{
+        maxChars: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    demote_builtin: z.ZodOptional<z.ZodBoolean>;
     background_task: z.ZodOptional<z.ZodObject<{
         defaultConcurrency: z.ZodOptional<z.ZodNumber>;
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;

package/dist/hooks/comment-checker.d.ts

@@ -7,7 +7,7 @@ export interface CommentCheckResult {
 export declare function isCodeFile(filePath: string): boolean;
 export declare function checkComments(content: string, filePath: string, maxRatio?: number, slopThreshold?: number): CommentCheckResult;
 export declare function createCommentCheckerHook(internalSessions: Set<string>, maxRatio?: number, slopThreshold?: number): (input: {
-    tool: {
+    tool: string | {
         name: string;
     };
     args: Record<string, unknown>;

package/dist/hooks/keyword-detector.d.ts

@@ -1,5 +1,5 @@
 export interface DetectedKeyword {
-    type: "ultrawork" | "search" | "analyze";
+    type: "ultrawork" | "search" | "analyze" | "think";
     message: string;
 }
 export declare function removeCodeBlocks(text: string): string;

package/dist/hooks/rules-injector.d.ts

@@ -1,2 +1,4 @@
 export declare function loadRules(projectDir: string): string | null;
+export declare function loadArchitecture(projectDir: string): string | null;
+export declare function loadCodeStyle(projectDir: string): string | null;
 export declare function clearRulesCache(): void;

package/dist/hooks/session-compaction.d.ts

@@ -0,0 +1,21 @@
+type MessageLike = {
+    role?: string;
+    content?: string;
+    info?: {
+        role?: string;
+    };
+    parts?: Array<{
+        type: string;
+        text?: string;
+    }>;
+};
+export declare function buildSessionSummary(messages: MessageLike[]): string;
+export declare function createSessionCompactionHook(ctx: {
+    client: any;
+}, internalSessions: Set<string>): (input: {
+    sessionID: string;
+}, output: {
+    context: string[];
+    prompt?: string;
+}) => Promise<void>;
+export {};

package/dist/hooks/token-truncation.d.ts

@@ -0,0 +1,9 @@
+export declare function truncateMiddle(input: string, maxChars: number): string;
+export declare function createTokenTruncationHook(internalSessions: Set<string>, maxChars?: number): (input: {
+    tool: string | {
+        name: string;
+    };
+    sessionID: string;
+}, output: {
+    output: string;
+}) => void;

package/dist/index.js

@@ -14400,6 +14400,10 @@ var PluginConfigSchema = exports_external.object({
   disabled_hooks: exports_external.array(exports_external.string()).optional(),
   disabled_tools: exports_external.array(exports_external.string()).optional(),
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
+  token_truncation: exports_external.object({
+    maxChars: exports_external.number().min(1).optional()
+  }).optional(),
+  demote_builtin: exports_external.boolean().optional(),
   background_task: exports_external.object({
     defaultConcurrency: exports_external.number().optional(),
     providerConcurrency: exports_external.record(exports_external.string(), exports_external.number()).optional(),
@@ -14510,15 +14514,15 @@ function loadConfig(projectDir) {
 // src/agents/index.ts
 var BUILTIN_AGENTS = {
   sisyphus: {
-    model: "anthropic/claude-opus-4-5",
-    description: "Primary orchestrator \u2014 analyzes requests, delegates to specialists, verifies results",
+    model: "openai-codex/gpt-5.3-codex",
+    description: "Primary orchestrator \u2014 analyzes requests, reads code directly, delegates implementation to specialists",
     prompt: "__DYNAMIC__",
     maxTokens: 64000,
-    thinking: { type: "enabled", budgetTokens: 32000 },
+    reasoningEffort: "high",
     tools: {
-      Grep: false,
-      Glob: false,
-      Read: false,
+      Grep: true,
+      Glob: true,
+      Read: true,
       Write: false,
       Edit: false,
       Bash: false
@@ -14622,17 +14626,19 @@ ${example1}
 
 Estimated agents: N | Phases: M`;
 }
-var SISYPHUS_PROMPT_TEMPLATE = (agentTable, planExample) => `You are Sisyphus, the ORCHESTRATOR. You do NOT do the work yourself.
+var SISYPHUS_PROMPT_TEMPLATE = (agentTable, planExample) => `You are Sisyphus, the ORCHESTRATOR. You read code yourself and delegate implementation.
 
 ## YOUR ROLE
-You are a conductor. You THINK, PLAN, and DELEGATE via spawn_agent.
-Your specialist agents run on models optimized for their tasks \u2014 faster and cheaper than you.
-When you do Grep/Glob/Read directly, you waste your own expensive tokens on work a specialist does better.
+You are a conductor who can read the score directly. You THINK, READ, PLAN, and DELEGATE writing via spawn_agent.
+You can use Grep, Glob, Read to understand the codebase \u2014 this is FASTER than spawning an explore agent.
+Your specialist agents handle WRITING code, running tests, and implementation tasks.
 
 ## RULES
-- Do NOT use Grep, Glob, Read, Write, Edit, Bash directly. Delegate via spawn_agent.
+- You CAN use Grep, Glob, Read directly \u2014 read code to understand context before planning.
+- You CANNOT use Write, Edit, Bash \u2014 delegate these via spawn_agent.
 - You may: use spawn_agent, track TODOs, ask the user questions, synthesize agent results.
-- Always run independent tasks in PARALLEL via spawn_agent.
+- Always run independent IMPLEMENTATION tasks in PARALLEL via spawn_agent.
+- Do NOT spawn agents just to read files \u2014 do that yourself.
 
 ## AGENTS (via spawn_agent)
 ${agentTable}
@@ -14706,6 +14712,7 @@ function buildAgents(config2) {
 var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 var INLINE_CODE_PATTERN = /`[^`]+`/g;
 var ULTRAWORK_PATTERN = /\b(ultrawork|ulw)\b/i;
+var THINK_PATTERN = /\b(think\s+hard|think\s+through|think\s+deeply|think\s+carefully)\b|\u3058\u3063\u304F\u308A|\u6DF1\u304F\u8003\u3048\u3066|\u719F\u8003/i;
 var SEARCH_PATTERN = /\b(search|find|locate|lookup|look\s*up|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all|\u691C\u7D22|\u63A2\u3057\u3066|\u898B\u3064\u3051\u3066|\u30B5\u30FC\u30C1|\u63A2\u7D22|\u30B9\u30AD\u30E3\u30F3|\u3069\u3053|\u767A\u898B|\u635C\u7D22|\u898B\u3064\u3051\u51FA\u3059|\u4E00\u89A7|\u641C\u7D22|\u67E5\u627E|\u5BFB\u627E|\u67E5\u8BE2|\u68C0\u7D22|\u5B9A\u4F4D|\u626B\u63CF|\u53D1\u73B0|\u5728\u54EA\u91CC|\u627E\u51FA\u6765|\u5217\u51FA/i;
 var ANALYZE_PATTERN = /\b(analyze|analyse|investigate|examine|research|study|deep[\s-]?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to|\u5206\u6790|\u8ABF\u67FB|\u89E3\u6790|\u691C\u8A0E|\u7814\u7A76|\u8A3A\u65AD|\u7406\u89E3|\u8AAC\u660E|\u691C\u8A3C|\u7CBE\u67FB|\u7A76\u660E|\u30C7\u30D0\u30C3\u30B0|\u306A\u305C|\u3069\u3046|\u4ED5\u7D44\u307F|\u8C03\u67E5|\u68C0\u67E5|\u5256\u6790|\u6DF1\u5165|\u8BCA\u65AD|\u89E3\u91CA|\u8C03\u8BD5|\u4E3A\u4EC0\u4E48|\u539F\u7406|\u641E\u6E05\u695A|\u5F04\u660E\u767D/i;
 function removeCodeBlocks(text) {
@@ -14717,7 +14724,8 @@ function extractPromptText(parts) {
 var KEYWORD_DEFS = [
   { pattern: ULTRAWORK_PATTERN, type: "ultrawork", getMessage: () => ULTRAWORK_MESSAGE },
   { pattern: SEARCH_PATTERN, type: "search", getMessage: () => SEARCH_MESSAGE },
-  { pattern: ANALYZE_PATTERN, type: "analyze", getMessage: () => ANALYZE_MESSAGE }
+  { pattern: ANALYZE_PATTERN, type: "analyze", getMessage: () => ANALYZE_MESSAGE },
+  { pattern: THINK_PATTERN, type: "think", getMessage: () => THINK_MESSAGE }
 ];
 function detectKeywords(text) {
   const clean = removeCodeBlocks(text);
@@ -14806,32 +14814,65 @@ IF COMPLEX \u2014 DO NOT STRUGGLE ALONE. Consult specialists:
 - **Oracle**: Conventional problems (architecture, debugging, complex logic)
 
 SYNTHESIZE findings before proceeding.`;
+var THINK_MESSAGE = `Extended thinking enabled. Take your time to reason thoroughly.`;
 
 // src/hooks/rules-injector.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-var cachedRules = null;
-var cachedPath = null;
-function loadRules(projectDir) {
-  const rulesPath = path2.join(projectDir, ".opencode", "rules.md");
+var cache = new Map;
+function loadCachedFile(filePath) {
   try {
-    if (!fs2.existsSync(rulesPath))
+    if (!fs2.existsSync(filePath))
       return null;
-    const stat = fs2.statSync(rulesPath);
+    const stat = fs2.statSync(filePath);
     const mtime = stat.mtimeMs;
-    if (cachedPath === rulesPath && cachedRules && cachedRules.mtime === mtime) {
-      return cachedRules.content;
-    }
-    const content = fs2.readFileSync(rulesPath, "utf-8");
-    cachedPath = rulesPath;
-    cachedRules = { content, mtime };
-    log(`Rules loaded from ${rulesPath}`);
+    const cached2 = cache.get(filePath);
+    if (cached2 && cached2.mtime === mtime)
+      return cached2.content;
+    const content = fs2.readFileSync(filePath, "utf-8");
+    cache.set(filePath, { content, mtime });
     return content;
   } catch (err) {
-    log(`Error loading rules: ${err}`);
+    log(`Error loading file: ${err}`, { filePath });
     return null;
   }
 }
+function loadFirstExisting(projectDir, relativePaths) {
+  for (const rel of relativePaths) {
+    const p = path2.join(projectDir, rel);
+    const content = loadCachedFile(p);
+    if (content !== null)
+      return { path: p, content };
+  }
+  return null;
+}
+function loadRules(projectDir) {
+  const hit = loadFirstExisting(projectDir, [path2.join(".opencode", "rules.md")]);
+  if (!hit)
+    return null;
+  log(`Rules loaded from ${hit.path}`);
+  return hit.content;
+}
+function loadArchitecture(projectDir) {
+  const hit = loadFirstExisting(projectDir, [
+    path2.join(".opencode", "ARCHITECTURE.md"),
+    "ARCHITECTURE.md"
+  ]);
+  if (!hit)
+    return null;
+  log(`Architecture loaded from ${hit.path}`);
+  return hit.content;
+}
+function loadCodeStyle(projectDir) {
+  const hit = loadFirstExisting(projectDir, [
+    path2.join(".opencode", "CODE_STYLE.md"),
+    "CODE_STYLE.md"
+  ]);
+  if (!hit)
+    return null;
+  log(`Code style loaded from ${hit.path}`);
+  return hit.content;
+}
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
 var exports_external2 = {};
@@ -27630,7 +27671,8 @@ function buildWarning(ratio, slopCount, maxRatio, slopThreshold) {
 }
 function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshold = 3) {
   return (input, output) => {
-    if (input.tool.name !== "Write" && input.tool.name !== "Edit")
+    const toolName = typeof input.tool === "string" ? input.tool : input.tool.name;
+    if (toolName !== "Write" && toolName !== "Edit")
       return;
     if (internalSessions.has(input.sessionID))
       return;
@@ -27653,6 +27695,150 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
   };
 }
 
+// src/hooks/token-truncation.ts
+var DEFAULT_MAX_CHARS = 30000;
+function truncateMiddle(input, maxChars) {
+  if (!Number.isFinite(maxChars) || maxChars <= 0)
+    return input;
+  if (input.length <= maxChars)
+    return input;
+  if (maxChars < 32)
+    return input.slice(0, maxChars);
+  const len = input.length;
+  let head = Math.floor(maxChars * 0.4);
+  let tail = Math.floor(maxChars * 0.4);
+  head = Math.min(Math.max(head, 1), maxChars);
+  const buildMarker = (removed2) => `
+
+... [truncated ${removed2} chars] ...
+
+`;
+  const finalize2 = (h, t) => {
+    const removed2 = Math.max(0, len - h - t);
+    const marker2 = buildMarker(removed2);
+    const availableTail2 = maxChars - h - marker2.length;
+    const finalTail = Math.max(0, Math.min(t, availableTail2));
+    const finalRemoved = Math.max(0, len - h - finalTail);
+    const finalMarker = buildMarker(finalRemoved);
+    const availableTail22 = maxChars - h - finalMarker.length;
+    const finalTail2 = Math.max(0, Math.min(finalTail, availableTail22));
+    const removed22 = Math.max(0, len - h - finalTail2);
+    const marker22 = buildMarker(removed22);
+    const budget = h + marker22.length + finalTail2;
+    if (budget > maxChars) {
+      return input.slice(0, maxChars);
+    }
+    return input.slice(0, h) + marker22 + input.slice(len - finalTail2);
+  };
+  const removed = Math.max(0, len - head - tail);
+  const marker = buildMarker(removed);
+  const availableTail = maxChars - head - marker.length;
+  if (availableTail < 0) {
+    const shrinkHead = Math.max(0, maxChars - marker.length);
+    return finalize2(shrinkHead, 0);
+  }
+  tail = Math.min(tail, availableTail);
+  return finalize2(head, tail);
+}
+function createTokenTruncationHook(internalSessions, maxChars = DEFAULT_MAX_CHARS) {
+  const budget = Number.isFinite(maxChars) ? Math.max(1, Math.floor(maxChars)) : DEFAULT_MAX_CHARS;
+  return (input, output) => {
+    if (internalSessions.has(input.sessionID))
+      return;
+    const before = output.output;
+    const after = truncateMiddle(before, budget);
+    if (after !== before) {
+      output.output = after;
+      const toolName = typeof input.tool === "string" ? input.tool : input.tool.name;
+      log("Token truncation applied", { tool: toolName, before: before.length, after: after.length });
+    }
+  };
+}
+
+// src/hooks/session-compaction.ts
+function partsToText(parts) {
+  if (!parts)
+    return "";
+  return parts.filter((p) => p && p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+}
+function getRole(m) {
+  return (m.role ?? m.info?.role ?? "").toLowerCase();
+}
+function getText(m) {
+  if (typeof m.content === "string")
+    return m.content;
+  return partsToText(m.parts);
+}
+function uniq(items) {
+  const seen = new Set;
+  const out = [];
+  for (const it of items) {
+    const k = typeof it === "string" ? it : JSON.stringify(it);
+    if (seen.has(k))
+      continue;
+    seen.add(k);
+    out.push(it);
+  }
+  return out;
+}
+var FILE_PATH_RE = /(?:(?:[A-Za-z]:\\)?[\w.-]+(?:[\\/][\w.-]+)+)\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|toml|yaml|yml|py|go|rs|java|kt|c|cpp|h|hpp|cs|swift|vue|svelte)/g;
+function buildSessionSummary(messages) {
+  const assistantTexts = messages.filter((m) => getRole(m) === "assistant").map((m) => getText(m)).map((t) => t.trim()).filter(Boolean);
+  const combined = assistantTexts.join(`
+`);
+  const files = uniq((combined.match(FILE_PATH_RE) ?? []).map((s) => s.replace(/^[`"']|[`"']$/g, "")));
+  const decisionLines = uniq(assistantTexts.flatMap((t) => t.split(`
+`)).map((l) => l.trim()).filter((l) => /(decid|we will|should|must|chosen|choice|\u65B9\u91DD|\u6C7A\u5B9A|\u63A1\u7528)/i.test(l)).slice(0, 10));
+  const nextLines = uniq(assistantTexts.flatMap((t) => t.split(`
+`)).map((l) => l.trim()).filter((l) => /(next\s*steps?|todo|next:|\u6B21\s*\u306B|\u3084\u308B|TODO)/i.test(l)).slice(0, 10));
+  const currentState = (assistantTexts[assistantTexts.length - 1] ?? "").slice(0, 800).trim();
+  const lines = [];
+  lines.push("## Session Summary");
+  lines.push("");
+  lines.push("### Key Decisions");
+  if (decisionLines.length === 0)
+    lines.push("- (none)");
+  else
+    for (const l of decisionLines)
+      lines.push(`- ${l}`);
+  lines.push("");
+  lines.push("### Files Modified");
+  if (files.length === 0)
+    lines.push("- (none)");
+  else
+    for (const f of files)
+      lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("### Current State");
+  lines.push(currentState ? `- ${currentState}` : "- (none)");
+  lines.push("");
+  lines.push("### Next Steps");
+  if (nextLines.length === 0)
+    lines.push("- (none)");
+  else
+    for (const l of nextLines)
+      lines.push(`- ${l}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function createSessionCompactionHook(ctx, internalSessions) {
+  return async (input, output) => {
+    if (internalSessions.has(input.sessionID))
+      return;
+    try {
+      const res = await ctx.client?.session?.listMessages?.({ id: input.sessionID });
+      const msgs = res?.messages ?? res ?? [];
+      const summary = buildSessionSummary(msgs);
+      output.context.push(summary);
+      output.prompt = "Output a compact session summary in the EXACT format below. " + "Use the provided '## Session Summary' scaffold from context as your base; do not add extra sections.";
+    } catch (err) {
+      log("Session compaction hook failed", { error: err });
+      output.prompt = "Summarize the session using this exact template: ## Session Summary; ### Key Decisions; ### Files Modified; ### Current State; ### Next Steps.";
+    }
+  };
+}
+
 // src/concurrency/semaphore.ts
 class Semaphore {
   max;
@@ -27791,6 +27977,8 @@ var OpenCodeUltra = async (ctx) => {
   const ralphTools = createRalphLoopTools(ctx, internalSessions);
   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);
+  const sessionCompactionHook = createSessionCompactionHook(ctx, internalSessions);
   const pendingKeywords = new Map;
   log("Config loaded", {
     agentCount: Object.keys(agents).length,
@@ -27835,6 +28023,15 @@ var OpenCodeUltra = async (ctx) => {
         ...existingAgents,
         ...agentConfigs
       };
+      if (pluginConfig.demote_builtin !== false) {
+        const agentMap = config3.agent;
+        for (const name of ["build", "plan", "triage", "docs"]) {
+          const cur = agentMap[name];
+          if (cur && typeof cur === "object") {
+            agentMap[name] = { ...cur, mode: "subagent" };
+          }
+        }
+      }
       log("Agents registered", { agents: Object.keys(agentConfigs) });
     },
     "chat.message": async (input, output) => {
@@ -27896,11 +28093,33 @@ var OpenCodeUltra = async (ctx) => {
 ${rules}`);
         }
       }
+      if (!disabledHooks.has("context-injector")) {
+        const arch = loadArchitecture(ctx.directory);
+        if (arch) {
+          output.system.push(`## Architecture
+
+${arch}`);
+        }
+        const style = loadCodeStyle(ctx.directory);
+        if (style) {
+          output.system.push(`## Code Style
+
+${style}`);
+        }
+      }
+    },
+    "experimental.session.compacting": async (input, output) => {
+      if (disabledHooks.has("session-compaction"))
+        return;
+      await sessionCompactionHook(input, output);
     },
     "tool.execute.after": async (input, output) => {
       if (!disabledHooks.has("comment-checker")) {
         commentCheckerHook(input, output);
       }
+      if (!disabledHooks.has("token-truncation")) {
+        tokenTruncationHook(input, output);
+      }
     },
     event: async ({ event }) => {
       if (event.type === "session.deleted") {

package/package.json

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