opencode-ultra 0.2.2 → 0.4.0

package/dist/config.d.ts

@@ -34,6 +34,19 @@ declare const PluginConfigSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         variant: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
+    fragments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    prompt_renderer: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            markdown: "markdown";
+            xml: "xml";
+            json: "json";
+        }>>;
+        model_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            markdown: "markdown";
+            xml: "xml";
+            json: "json";
+        }>>>;
+    }, z.core.$strip>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;

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/fragment-injector.d.ts

@@ -0,0 +1,9 @@
+export type FragmentsConfig = Record<string, string[]>;
+export declare function createFragmentInjector(ctx: {
+    directory: string;
+}, internalSessions: Set<string>, fragments?: FragmentsConfig): (input: {
+    sessionID?: string;
+    agent?: string;
+}, output: {
+    system: string[];
+}) => Promise<void>;

package/dist/hooks/prompt-renderer.d.ts

@@ -0,0 +1,13 @@
+export type PromptFormat = "markdown" | "xml" | "json";
+export type PromptRendererConfig = {
+    default: PromptFormat;
+    model_overrides: Record<string, PromptFormat>;
+};
+export declare function resolvePromptFormat(inputModel: any, config?: Partial<PromptRendererConfig>): PromptFormat;
+export declare function formatSystemSection(format: PromptFormat, content: string): string;
+export declare function createPromptRendererHook(internalSessions: Set<string>, config?: Partial<PromptRendererConfig>): (input: {
+    sessionID?: string;
+    model?: unknown;
+}, output: {
+    system: string[];
+}) => void;

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

@@ -14396,6 +14396,11 @@ var CategoryConfigSchema = exports_external.object({
 var PluginConfigSchema = exports_external.object({
   agents: AgentOverridesSchema.optional(),
   categories: exports_external.record(exports_external.string(), CategoryConfigSchema).optional(),
+  fragments: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
+  prompt_renderer: exports_external.object({
+    default: exports_external.enum(["markdown", "xml", "json"]).optional(),
+    model_overrides: exports_external.record(exports_external.string(), exports_external.enum(["markdown", "xml", "json"])).optional()
+  }).optional(),
   disabled_agents: exports_external.array(exports_external.string()).optional(),
   disabled_hooks: exports_external.array(exports_external.string()).optional(),
   disabled_tools: exports_external.array(exports_external.string()).optional(),
@@ -14819,28 +14824,148 @@ var THINK_MESSAGE = `Extended thinking enabled. Take your time to reason thoroug
 // 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;
+}
+
+// src/hooks/fragment-injector.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var cache2 = new Map;
+async function readCached(absPath) {
+  try {
+    const st = await fs3.promises.stat(absPath);
+    if (!st.isFile())
+      return null;
+    const prev = cache2.get(absPath);
+    if (prev && prev.mtimeMs === st.mtimeMs)
+      return prev.content;
+    const content = await fs3.promises.readFile(absPath, "utf-8");
+    cache2.set(absPath, { mtimeMs: st.mtimeMs, content });
+    return content;
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      log("fragment read failed", { path: absPath, error: String(err) });
+    }
     return null;
   }
 }
+function createFragmentInjector(ctx, internalSessions, fragments) {
+  return async (input, output) => {
+    if (input.sessionID && internalSessions.has(input.sessionID))
+      return;
+    const agent = input.agent;
+    if (!agent || !fragments)
+      return;
+    const fragmentPaths = fragments[agent];
+    if (!Array.isArray(fragmentPaths) || fragmentPaths.length === 0)
+      return;
+    for (const rel of fragmentPaths) {
+      const abs = path3.resolve(ctx.directory, rel);
+      const content = await readCached(abs);
+      if (content === null) {
+        log("fragment file not found; skipping", { agent, path: rel });
+        continue;
+      }
+      output.system.push(content);
+    }
+  };
+}
+
+// src/hooks/prompt-renderer.ts
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function resolvePromptFormat(inputModel, config2) {
+  const def = config2?.default ?? "markdown";
+  const overrides = config2?.model_overrides ?? {};
+  const providerID = inputModel?.providerID;
+  const modelID = inputModel?.modelID;
+  const key = typeof providerID === "string" && typeof modelID === "string" ? `${providerID}/${modelID}` : undefined;
+  if (key && overrides[key])
+    return overrides[key];
+  if (typeof modelID === "string" && overrides[modelID])
+    return overrides[modelID];
+  return def;
+}
+function formatSystemSection(format2, content) {
+  if (format2 === "markdown")
+    return content;
+  if (format2 === "xml") {
+    return `<section name="Rules">${escapeXml(content)}</section>`;
+  }
+  if (format2 === "json") {
+    return JSON.stringify({ section: "Rules", content });
+  }
+  return content;
+}
+function createPromptRendererHook(internalSessions, config2) {
+  return (input, output) => {
+    if (input.sessionID && internalSessions.has(input.sessionID))
+      return;
+    if (!Array.isArray(output.system) || output.system.length === 0)
+      return;
+    const format2 = resolvePromptFormat(input.model, config2);
+    if (format2 === "markdown")
+      return;
+    try {
+      output.system = output.system.map((s) => formatSystemSection(format2, s));
+    } catch (err) {
+      log("prompt renderer failed", { error: String(err) });
+    }
+  };
+}
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
 var exports_external2 = {};
@@ -15571,15 +15696,15 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path3) {
-  if (!path3)
+function getElementAtPath2(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises2 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises2).then((results) => {
     const resolvedObj = {};
     for (let i = 0;i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -15933,11 +16058,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path3, issues) {
+function prefixIssues2(path4, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -16105,7 +16230,7 @@ function treeifyError2(error48, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error49, path3 = []) => {
+  const processError = (error49, path4 = []) => {
     var _a2, _b;
     for (const issue3 of error49.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -16115,7 +16240,7 @@ function treeifyError2(error48, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path3, ...issue3.path];
+        const fullpath = [...path4, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -16147,8 +16272,8 @@ function treeifyError2(error48, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27487,6 +27612,243 @@ Original task:
 ${original}`;
 }
 
+// src/tools/batch-read.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var MAX_PATHS = 20;
+function resolvePath(projectDir, inputPath) {
+  return path4.isAbsolute(inputPath) ? inputPath : path4.join(projectDir, inputPath);
+}
+function isProbablyBinary(buf) {
+  const sample = buf.subarray(0, Math.min(buf.length, 8192));
+  for (const b of sample) {
+    if (b === 0)
+      return true;
+  }
+  return false;
+}
+async function readOne(projectDir, inputPath) {
+  const abs = resolvePath(projectDir, inputPath);
+  try {
+    const stat = await fs4.promises.stat(abs);
+    if (!stat.isFile()) {
+      return `=== ${inputPath} ===
+[File not found]
+`;
+    }
+    const buf = await fs4.promises.readFile(abs);
+    if (isProbablyBinary(buf)) {
+      return `=== ${inputPath} ===
+[Binary file]
+`;
+    }
+    const content = buf.toString("utf-8");
+    return `=== ${inputPath} ===
+${content}
+`;
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return `=== ${inputPath} ===
+[File not found]
+`;
+    }
+    log("batch_read failed to read file", { path: abs, error: String(err) });
+    return `=== ${inputPath} ===
+[File not found]
+`;
+  }
+}
+function createBatchReadTool(ctx) {
+  return tool({
+    description: "Read multiple files in parallel and concatenate contents.",
+    args: {
+      paths: tool.schema.array(tool.schema.string()).describe("File paths (max 20).")
+    },
+    execute: async ({ paths }) => {
+      if (!Array.isArray(paths)) {
+        return "Error: paths must be an array of strings";
+      }
+      if (paths.length > MAX_PATHS) {
+        return `Error: maximum ${MAX_PATHS} paths allowed`;
+      }
+      const results = await Promise.all(paths.map((p) => readOne(ctx.directory, p)));
+      return results.join("");
+    }
+  });
+}
+
+// src/tools/continuity-ledger.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function normalizeLedgerName(name) {
+  const trimmed = (name ?? "").trim().replace(/\.md$/i, "");
+  const spaced = trimmed.replace(/\s+/g, "-");
+  const cleaned = spaced.replace(/[^A-Za-z0-9._-]/g, "");
+  return cleaned.length > 0 ? cleaned : "ledger";
+}
+function ledgerDir(projectDir) {
+  return path5.join(projectDir, ".opencode", "ledgers");
+}
+function ledgerPath(projectDir, name) {
+  return path5.join(ledgerDir(projectDir), `${normalizeLedgerName(name)}.md`);
+}
+function createLedgerSaveTool(ctx) {
+  return tool({
+    description: "Save a continuity ledger markdown document to .opencode/ledgers/.",
+    args: {
+      name: tool.schema.string().describe('Ledger name (e.g. "auth-refactor").'),
+      content: tool.schema.string().describe("Markdown content.")
+    },
+    execute: async ({ name, content }) => {
+      const dir = ledgerDir(ctx.directory);
+      const outPath = ledgerPath(ctx.directory, name);
+      try {
+        await fs5.promises.mkdir(dir, { recursive: true });
+        await fs5.promises.writeFile(outPath, content, "utf-8");
+        return `Saved to .opencode/ledgers/${path5.basename(outPath)}`;
+      } catch (err) {
+        log("ledger_save failed", { error: String(err) });
+        return `Error: failed to save ledger`;
+      }
+    }
+  });
+}
+function createLedgerLoadTool(ctx) {
+  return tool({
+    description: "Load a continuity ledger markdown document from .opencode/ledgers/.",
+    args: {
+      name: tool.schema.string().optional().describe("Ledger name (defaults to most recent).")
+    },
+    execute: async ({ name }) => {
+      const dir = ledgerDir(ctx.directory);
+      try {
+        if (name && name.trim().length > 0) {
+          const p = ledgerPath(ctx.directory, name);
+          if (!fs5.existsSync(p))
+            return "No ledgers found";
+          return await fs5.promises.readFile(p, "utf-8");
+        }
+        if (!fs5.existsSync(dir))
+          return "No ledgers found";
+        const entries = await fs5.promises.readdir(dir);
+        const files = entries.filter((e) => e.toLowerCase().endsWith(".md")).map((e) => path5.join(dir, e));
+        if (files.length === 0)
+          return "No ledgers found";
+        let latest = files[0];
+        let latestMtime = -1;
+        for (const f of files) {
+          try {
+            const st = await fs5.promises.stat(f);
+            if (st.mtimeMs > latestMtime) {
+              latestMtime = st.mtimeMs;
+              latest = f;
+            }
+          } catch {}
+        }
+        return await fs5.promises.readFile(latest, "utf-8");
+      } catch (err) {
+        log("ledger_load failed", { error: String(err) });
+        return "No ledgers found";
+      }
+    }
+  });
+}
+
+// src/tools/ast-search.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { spawnSync } from "child_process";
+var MAX_MATCHES = 50;
+function stripAnsi(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function resolveSearchPath(projectDir, p) {
+  return path6.isAbsolute(p) ? p : path6.join(projectDir, p);
+}
+function candidatesFor(bin) {
+  const out = [bin];
+  if (process.platform === "win32") {
+    out.push(`${bin}.exe`, `${bin}.cmd`, `${bin}.bat`);
+  }
+  return out;
+}
+function findAstGrepBinary() {
+  const pathEnv = process.env.PATH ?? "";
+  const dirs = pathEnv.split(path6.delimiter).filter(Boolean);
+  const bins = ["sg", "ast-grep"];
+  for (const dir of dirs) {
+    for (const b of bins) {
+      for (const cand of candidatesFor(b)) {
+        const full = path6.join(dir, cand);
+        try {
+          const st = fs6.statSync(full);
+          if (!st.isFile())
+            continue;
+          fs6.accessSync(full, fs6.constants.X_OK);
+          return full;
+        } catch {}
+      }
+    }
+  }
+  return null;
+}
+function normalizeOutput(stdout) {
+  const lines = stripAnsi(stdout).split(`
+`).map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  const out = [];
+  for (const line of lines) {
+    const m3 = line.match(/^(.*?):(\d+):(\d+):(.*)$/);
+    if (m3) {
+      out.push(`${m3[1]}:${m3[2]}: ${m3[4].trim()}`);
+      continue;
+    }
+    const m2 = line.match(/^(.*?):(\d+):(.*)$/);
+    if (m2) {
+      out.push(`${m2[1]}:${m2[2]}: ${m2[3].trim()}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.slice(0, MAX_MATCHES).join(`
+`);
+}
+function createAstSearchTool(ctx, binaryPath) {
+  return tool({
+    description: "AST-aware code search using ast-grep (sg).",
+    args: {
+      pattern: tool.schema.string().describe('ast-grep pattern (e.g. "console.log($$$)").'),
+      path: tool.schema.string().optional().describe("Directory to search (default: project root)."),
+      lang: tool.schema.string().optional().describe('Language (e.g. "typescript", "python").')
+    },
+    execute: async ({ pattern, path: searchPath, lang }) => {
+      const target = resolveSearchPath(ctx.directory, searchPath ?? ".");
+      const args = ["--pattern", pattern, target];
+      if (lang && lang.trim().length > 0) {
+        args.push("--lang", lang);
+      }
+      const res = spawnSync(binaryPath, args, {
+        cwd: ctx.directory,
+        encoding: "utf-8"
+      });
+      if (res.error) {
+        log("ast_search spawn failed", { error: String(res.error) });
+        return `Error: ${String(res.error)}`;
+      }
+      const stdout = res.stdout ?? "";
+      const stderr = res.stderr ?? "";
+      if ((res.status ?? 0) === 1 && stdout.trim().length === 0) {
+        return "No matches";
+      }
+      if ((res.status ?? 0) !== 0 && (res.status ?? 0) !== 1) {
+        log("ast_search failed", { status: res.status, stderr });
+        return stderr.trim().length > 0 ? stderr.trim() : "Error: ast_search failed";
+      }
+      const normalized = normalizeOutput(stdout);
+      return normalized.length > 0 ? normalized : "No matches";
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -27569,7 +27931,7 @@ ${unfinished.map((t) => `- [ ] ${t.text}`).join(`
 }
 
 // src/hooks/comment-checker.ts
-import * as fs3 from "fs";
+import * as fs7 from "fs";
 var AI_SLOP_PATTERNS = [
   /\/\/ .{80,}/,
   /\/\/ (This|The|We|Here|Note:)/i,
@@ -27639,7 +28001,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;
@@ -27647,7 +28010,7 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
     if (!filePath || !isCodeFile(filePath))
       return;
     try {
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs7.readFileSync(filePath, "utf-8");
       const result = checkComments(content, filePath, maxRatio, slopThreshold);
       if (result.shouldWarn) {
         output.output += `
@@ -27662,6 +28025,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;
@@ -27675,10 +28182,10 @@ class Semaphore {
       this.active++;
       return;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       this.queue.push(() => {
         this.active++;
-        resolve();
+        resolve2();
       });
     });
   }
@@ -27798,8 +28305,17 @@ var OpenCodeUltra = async (ctx) => {
     resolveAgentModel
   });
   const ralphTools = createRalphLoopTools(ctx, internalSessions);
+  const batchRead = createBatchReadTool(ctx);
+  const ledgerSave = createLedgerSaveTool(ctx);
+  const ledgerLoad = createLedgerLoadTool(ctx);
+  const astGrepBin = findAstGrepBinary();
+  const astSearch = astGrepBin ? createAstSearchTool(ctx, astGrepBin) : null;
   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 fragmentInjector = createFragmentInjector(ctx, internalSessions, pluginConfig.fragments);
+  const promptRendererHook = createPromptRendererHook(internalSessions, pluginConfig.prompt_renderer);
   const pendingKeywords = new Map;
   log("Config loaded", {
     agentCount: Object.keys(agents).length,
@@ -27820,6 +28336,18 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("cancel_ralph")) {
     toolRegistry.cancel_ralph = ralphTools.cancel_ralph;
   }
+  if (!disabledTools.has("batch_read")) {
+    toolRegistry.batch_read = batchRead;
+  }
+  if (!disabledTools.has("ledger_save")) {
+    toolRegistry.ledger_save = ledgerSave;
+  }
+  if (!disabledTools.has("ledger_load")) {
+    toolRegistry.ledger_load = ledgerLoad;
+  }
+  if (!disabledTools.has("ast_search") && astSearch) {
+    toolRegistry.ast_search = astSearch;
+  }
   return {
     tool: toolRegistry,
     config: async (config3) => {
@@ -27844,6 +28372,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) => {
@@ -27905,11 +28442,39 @@ 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}`);
+        }
+      }
+      if (!disabledHooks.has("fragment-injector")) {
+        await fragmentInjector(input, output);
+      }
+      if (!disabledHooks.has("prompt-renderer")) {
+        promptRendererHook(input, output);
+      }
+    },
+    "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/dist/tools/ast-search.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function findAstGrepBinary(): string | null;
+export declare function createAstSearchTool(ctx: PluginInput, binaryPath: string): any;

package/dist/tools/batch-read.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createBatchReadTool(ctx: PluginInput): any;

package/dist/tools/continuity-ledger.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function normalizeLedgerName(name: string): string;
+export declare function createLedgerSaveTool(ctx: PluginInput): any;
+export declare function createLedgerLoadTool(ctx: PluginInput): any;

package/package.json

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