@webpresso/plugin-opencode 0.0.12 → 0.0.14

package/index.js

@@ -1,44 +1,807 @@
-import { accessSync, constants, statSync } from "node:fs";
+// src/host-adapters/opencode-plugin.ts
+import { spawn } from "node:child_process";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-const SESSION_START_HOOKS = ["sessionstart-routing"];
-const PRE_TOOL_HOOKS = ["pretool-guard"];
-const POST_TOOL_HOOKS = ["post-tool"];
+// src/hooks/lane/hook-bundle-manifest.ts
+var HOOK_BUNDLE_MANIFEST_VERSION = 1;
+var MAX_HOOK_BUNDLE_FILES = 4096;
+var MAX_MANIFEST_BYTES = 4 * 1024 * 1024;
+function statHookBundleFile(host, path) {
+  try {
+    const stats = host.statSync(path);
+    return stats.isFile() ? { path, mtimeMs: stats.mtimeMs, size: stats.size } : null;
+  } catch {
+    return null;
+  }
+}
+function isFileStat(host, value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return (
+    typeof record.path === "string" &&
+    host.isAbsolute(record.path) &&
+    typeof record.mtimeMs === "number" &&
+    typeof record.size === "number"
+  );
+}
+function isFileStatList(host, value) {
+  return (
+    Array.isArray(value) &&
+    value.length <= MAX_HOOK_BUNDLE_FILES &&
+    value.every((entry) => isFileStat(host, entry))
+  );
+}
+function parseHookBundleManifest(host, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (
+    record.version !== HOOK_BUNDLE_MANIFEST_VERSION ||
+    typeof record.entry !== "string" ||
+    typeof record.bun !== "string" ||
+    !isFileStatList(host, record.inputs) ||
+    !isFileStatList(host, record.outputs) ||
+    record.outputs.length === 0
+  ) {
+    return null;
+  }
+  return {
+    version: HOOK_BUNDLE_MANIFEST_VERSION,
+    entry: record.entry,
+    bun: record.bun,
+    inputs: record.inputs,
+    outputs: record.outputs,
+  };
+}
+function readHookBundleManifest(host, manifestPath) {
+  const stat = statHookBundleFile(host, manifestPath);
+  if (stat === null || stat.size > MAX_MANIFEST_BYTES) return null;
+  try {
+    return parseHookBundleManifest(host, host.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isUnchanged(host, recorded) {
+  const current = statHookBundleFile(host, recorded.path);
+  return current !== null && current.mtimeMs === recorded.mtimeMs && current.size === recorded.size;
+}
+function isHookBundleManifestFresh(host, manifest) {
+  const unchanged = (recorded) => isUnchanged(host, recorded);
+  return manifest.inputs.every(unchanged) && manifest.outputs.every(unchanged);
+}
 
-function extractAdditionalContext(envelope) {
-  return envelope?.hookSpecificOutput?.additionalContext ?? null;
+// src/host-adapters/opencode-output-filter.ts
+var REDIRECT_STDERR = "2>&1";
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var DURATION = /^\d+(?:\.\d+)?[smhd]?$/;
+var REFUSED_BARE = new Set(["$", "`", "<", ">", "(", ")", "{", "}", "\\", "#", "!"]);
+var REFUSED_DOUBLE_QUOTED = new Set(["$", "`", "\\"]);
+var WORD_TERMINATORS = new Set([" ", "\t", "&", "|", ";"]);
+var SINGLE_HEADS = new Map([
+  ["grep", "grep"],
+  ["rg", "rg"],
+  ["find", "find"],
+  ["fd", "fd"],
+  ["vitest", "vitest"],
+  ["tsc", "tsc"],
+  ["pytest", "pytest"],
+  ["mypy", "mypy"],
+  ["prettier", "prettier"],
+]);
+var PAIR_HEADS = new Map([
+  ["git log", "git-log"],
+  ["git diff", "git-diff"],
+  ["git status", "git-status"],
+  ["cargo test", "cargo-test"],
+  ["go test", "go-test"],
+  ["go build", "go-build"],
+  ["ruff check", "ruff-check"],
+  ["ruff format", "ruff-format"],
+]);
+function hasControlCharacter(input) {
+  for (let index = 0; index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    if ((code < 32 && code !== 9) || code === 127) return true;
+  }
+  return false;
+}
+function scanSingleQuoted(input, start) {
+  const close = input.indexOf("'", start + 1);
+  return close === -1 ? null : close + 1;
+}
+function scanDoubleQuoted(input, start) {
+  for (let index = start + 1; index < input.length; index += 1) {
+    const char = input.charAt(index);
+    if (char === '"') return index + 1;
+    if (REFUSED_DOUBLE_QUOTED.has(char)) return null;
+  }
+  return null;
+}
+function scanWord(input, start) {
+  let index = start;
+  let bare = true;
+  while (index < input.length && !WORD_TERMINATORS.has(input.charAt(index))) {
+    const char = input.charAt(index);
+    const quoted = char === "'" || char === '"';
+    if (!quoted && REFUSED_BARE.has(char)) return null;
+    const next = quoted
+      ? char === "'"
+        ? scanSingleQuoted(input, index)
+        : scanDoubleQuoted(input, index)
+      : index + 1;
+    if (next === null) return null;
+    bare = bare && !quoted;
+    index = next;
+  }
+  if (index === start) return null;
+  return { token: { kind: "word", raw: input.slice(start, index), bare }, end: index };
+}
+function scanOperator(input, start) {
+  const char = input.charAt(start);
+  if (char === ";") return { token: { kind: "op", op: ";" }, end: start + 1 };
+  if (char === "&" && input.charAt(start + 1) === "&") {
+    return { token: { kind: "op", op: "&&" }, end: start + 2 };
+  }
+  if (char === "|" && input.charAt(start + 1) !== "|") {
+    return { token: { kind: "op", op: "|" }, end: start + 1 };
+  }
+  return null;
+}
+function scanRedirect(input, start) {
+  if (!input.startsWith(REDIRECT_STDERR, start)) return null;
+  const end = start + REDIRECT_STDERR.length;
+  const after = input.charAt(end);
+  return after === "" || after === " " || after === "\t"
+    ? { token: { kind: "redirect" }, end }
+    : null;
+}
+function scanToken(input, start) {
+  return scanOperator(input, start) ?? scanRedirect(input, start) ?? scanWord(input, start);
+}
+function tokenize(input) {
+  if (hasControlCharacter(input)) return null;
+  const tokens = [];
+  let index = 0;
+  while (index < input.length) {
+    const char = input.charAt(index);
+    if (char === " " || char === "\t") {
+      index += 1;
+      continue;
+    }
+    const scanned = scanToken(input, index);
+    if (scanned === null) return null;
+    tokens.push(scanned.token);
+    index = scanned.end;
+  }
+  return tokens;
+}
+function splitSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (token.kind === "op" && token.op === "|") return null;
+    if (token.kind !== "op") {
+      current.push(token);
+      continue;
+    }
+    if (current.length === 0) return null;
+    segments.push(current);
+    current = [];
+  }
+  if (current.length === 0) return null;
+  segments.push(current);
+  return segments;
+}
+function isWord(token) {
+  return token?.kind === "word";
+}
+function isAssignment(token) {
+  return isWord(token) && ASSIGNMENT.test(token.raw);
+}
+function isBareWord(token, text) {
+  return isWord(token) && token.bare && token.raw === text;
+}
+function isPrefixSegment(segment) {
+  const [first, second] = segment;
+  if (segment.length === 1) return isAssignment(first);
+  if (segment.length !== 2 || !isWord(second)) return false;
+  if (isBareWord(first, "cd")) return true;
+  return isBareWord(first, "export") && isAssignment(second);
+}
+function producerWords(segment) {
+  const body = segment.at(-1)?.kind === "redirect" ? segment.slice(0, -1) : segment;
+  const words = body.filter(isWord);
+  return words.length === body.length ? words : null;
+}
+function skipTimeout(words) {
+  const [first, duration] = words;
+  if (!isBareWord(first, "timeout")) return words;
+  return isWord(duration) && DURATION.test(duration.raw) ? words.slice(2) : null;
+}
+function headFilter(words) {
+  const [first, second] = words;
+  if (!first?.bare) return null;
+  const single = SINGLE_HEADS.get(first.raw);
+  if (single !== undefined) return single;
+  if (!second?.bare) return null;
+  return PAIR_HEADS.get(`${first.raw} ${second.raw}`) ?? null;
+}
+function producerFilter(segment) {
+  const words = producerWords(segment);
+  if (words === null) return null;
+  const firstCommandWord = words.findIndex((word) => !ASSIGNMENT.test(word.raw));
+  if (firstCommandWord === -1) return null;
+  const afterTimeout = skipTimeout(words.slice(firstCommandWord));
+  return afterTimeout === null ? null : headFilter(afterTimeout);
+}
+function selectOutputFilter(command) {
+  const tokens = tokenize(command);
+  if (tokens === null) return null;
+  const segments = splitSegments(tokens);
+  const producer = segments?.at(-1);
+  if (segments === null || producer === undefined) return null;
+  if (!segments.slice(0, -1).every(isPrefixSegment)) return null;
+  return producerFilter(producer);
+}
+
+// src/host-adapters/opencode-session-budget.ts
+var OPENCODE_SESSION_BUDGET = {
+  inputCeilingTokens: 200000,
+  generalSteps: 150,
+};
+function ceilingFor(limit) {
+  const window = limit.input ?? limit.context;
+  if (limit.context <= 0 || window <= 0) return null;
+  return window > OPENCODE_SESSION_BUDGET.inputCeilingTokens
+    ? OPENCODE_SESSION_BUDGET.inputCeilingTokens
+    : null;
+}
+function stepsFor(current) {
+  return current === undefined ? OPENCODE_SESSION_BUDGET.generalSteps : null;
+}
+
+// src/host-adapters/opencode-plugin.ts
+var OPENCODE_MANAGED_HOOK_COMMANDS = {
+  sessionStart: "sessionstart-routing",
+  preTool: "pretool-guard",
+  postTool: "post-tool",
+};
+var OPENCODE_HOOK_EVENT_NAMES = {
+  sessionStart: "SessionStart",
+  preToolUse: "PreToolUse",
+  postToolUse: "PostToolUse",
+};
+var OPENCODE_PLUGIN_ID = "@webpresso/plugin-opencode";
+var OPENCODE_V2_DOMAIN_HOOKS = {
+  toolBefore: "execute.before",
+  toolAfter: "execute.after",
+  shellBefore: "create.before",
+  sessionCompaction: "compaction",
+};
+var OPENCODE_V2_SESSION_EVENTS = {
+  created: "session.created",
+  deleted: "session.deleted",
+};
+var OPENCODE_HOOK_ENV = {
+  projectDir: "CLAUDE_PROJECT_DIR",
+  hookHost: "WP_HOOK_HOST",
+};
+var OPENCODE_HOOK_HOST_NAME = "opencode";
+var SESSION_START_HOOKS = [OPENCODE_MANAGED_HOOK_COMMANDS.sessionStart];
+var PRE_TOOL_HOOKS = [OPENCODE_MANAGED_HOOK_COMMANDS.preTool];
+var POST_TOOL_HOOKS = [OPENCODE_MANAGED_HOOK_COMMANDS.postTool];
+var HOOK_BUDGET_MS = 5000;
+var SESSION_LOOKUP_TIMEOUT_MS = HOOK_BUDGET_MS;
+var HOOK_OUTPUT_CAP_BYTES = 1024 * 1024;
+var MAX_TRACKED_SESSIONS = 64;
+var MAX_CONTEXT_CHARS = 64 * 1024;
+var DEFAULT_DENY_REASON = "webpresso denied this tool call";
+var HOOK_LANE_ARGS = ["hook", "lane", "--json"];
+var SKIP_UPDATE_CHECK_ENV = "WP_SKIP_UPDATE_CHECK";
+var MAX_CACHED_LANES = 64;
+var HOOK_LANE_REFRESH_INTERVAL_MS = 30000;
+var HOOK_LANE_RETRY_COOLDOWN_MS = 60000;
+var OPENCODE_HOOK_OWNER_PID_ENV = "WP_HOOK_OWNER_PID";
+var HOOK_OWNER_PID_ENV = OPENCODE_HOOK_OWNER_PID_ENV;
+var PLUGIN_DEBUG_ENV = "WP_OPENCODE_PLUGIN_DEBUG";
+var SHELL_TOOL_ID = "shell";
+var SHELL_FILTER_MIN_BYTES = 4096;
+var RTK_PIPE_BUDGET_MS = 1500;
+var RTK_FOOTER_MARKER = "[wp: rtk pipe";
+var RAW_OUTPUT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+var RAW_OUTPUT_PRUNE_LIMIT = 500;
+var RAW_OUTPUT_DIR_MODE = 448;
+var RAW_OUTPUT_FILE_MODE = 384;
+var RAW_OUTPUT_SEGMENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
+var PACKAGED_WP_SHIM = join(dirname(fileURLToPath(import.meta.url)), "bin", "wp");
+function resolveWpLauncher(platform = process.platform, env = process.env) {
+  if (platform !== "win32") return PACKAGED_WP_SHIM;
+  if (env.WEBPRESSO_WP_BIN && env.WP_FORCE_JIT_PATH) {
+    throw new Error("WEBPRESSO_WP_BIN and WP_FORCE_JIT_PATH are both set; unset one.");
+  }
+  if (env.WEBPRESSO_WP_BIN) return env.WEBPRESSO_WP_BIN;
+  if (env.WP_FORCE_JIT_PATH) return join(env.WP_FORCE_JIT_PATH, "bin", "wp");
+  return join(env.USERPROFILE || homedir(), ".webpresso", "bin", "wp.exe");
+}
+function isExecutableFile(candidate) {
+  try {
+    const stat = statSync(candidate);
+    if (!stat.isFile()) return false;
+    if (process.platform !== "win32") accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveWpHookCommand() {
+  const launcher = resolveWpLauncher();
+  if (!isExecutableFile(launcher)) {
+    throw new Error(
+      `the webpresso wp launcher ${launcher} is not available; reinstall @webpresso/plugin-opencode or the Webpresso app.`,
+    );
+  }
+  return launcher;
+}
+function hookEnv(directory) {
+  return {
+    ...process.env,
+    [OPENCODE_HOOK_ENV.projectDir]: directory,
+    [OPENCODE_HOOK_ENV.hookHost]: OPENCODE_HOOK_HOST_NAME,
+  };
+}
+function launcherSpawn(launcher, directory, args) {
+  return { command: launcher, args, env: hookEnv(directory), group: false };
+}
+function failedRun(message) {
+  return { stdout: Buffer.alloc(0), stderr: Buffer.from(message), exitCode: null };
+}
+function collectBounded(stream) {
+  const chunks = [];
+  let bytes = 0;
+  stream.on("data", (chunk) => {
+    if (bytes < HOOK_OUTPUT_CAP_BYTES) {
+      chunks.push(chunk);
+      bytes += chunk.length;
+    }
+  });
+  return () => Buffer.concat(chunks);
+}
+var killProcess = (pid, signal) => {
+  process.kill(pid, signal);
+};
+function killProcessGroup(pid, kill = killProcess) {
+  if (pid === undefined) return;
+  try {
+    kill(-pid, "SIGKILL");
+  } catch {}
+}
+function processGroupHasMembers(pid, kill) {
+  try {
+    kill(-pid, 0);
+    return true;
+  } catch (error) {
+    return recordOf(error)?.code !== "ESRCH";
+  }
+}
+function sweepProcessGroup(pid, kill = killProcess) {
+  if (pid === undefined || !processGroupHasMembers(pid, kill)) return;
+  killProcessGroup(pid, kill);
+}
+function spawnHookProcess(spec, directory, stdinPayload) {
+  return new Promise((resolveRun) => {
+    if (spec.signal?.aborted === true) {
+      resolveRun(failedRun("aborted"));
+      return;
+    }
+    const child = spawn(spec.command, spec.args, {
+      cwd: directory,
+      env: spec.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: spec.group,
+    });
+    const stdout = collectBounded(child.stdout);
+    const stderr = collectBounded(child.stderr);
+    const terminate = () => {
+      if (spec.group) killProcessGroup(child.pid);
+      else child.kill("SIGKILL");
+    };
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      spec.signal?.removeEventListener("abort", onAbort);
+      if (spec.group) sweepProcessGroup(child.pid);
+      resolveRun(result);
+    };
+    const onAbort = () => {
+      terminate();
+      settle(failedRun("aborted"));
+    };
+    const budgetMs = spec.budgetMs ?? HOOK_BUDGET_MS;
+    const deadline = setTimeout(() => {
+      terminate();
+      settle(failedRun(`timed out after ${budgetMs} ms`));
+    }, budgetMs);
+    spec.signal?.addEventListener("abort", onAbort, { once: true });
+    let started = false;
+    child.on("spawn", () => {
+      started = true;
+    });
+    child.on("error", (error) => {
+      settle(
+        started ? failedRun(error.message) : { ...failedRun(error.message), notStarted: true },
+      );
+    });
+    child.on("close", (code) => {
+      settle({ stdout: stdout(), stderr: stderr(), exitCode: code });
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(stdinPayload);
+  });
+}
+var OPENCODE_HOOK_LANE_RUNTIME_ARGS = ["--no-install"];
+function absolutePathField(value) {
+  return typeof value === "string" && isAbsolute(value) ? value : null;
+}
+function bundleField(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  const run = absolutePathField(record.run);
+  const manifest = absolutePathField(record.manifest);
+  return run === null || manifest === null ? null : { run, manifest };
+}
+function isRuntimeArg(value) {
+  return typeof value === "string" && OPENCODE_HOOK_LANE_RUNTIME_ARGS.includes(value);
+}
+function runtimeArgsField(value) {
+  if (!Array.isArray(value) || value.length > OPENCODE_HOOK_LANE_RUNTIME_ARGS.length) return null;
+  return value.every(isRuntimeArg) ? [...value] : null;
+}
+function parseJsonRecord(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  return parsed;
+}
+function sourceLane(record, runtime, runtimeArgs) {
+  const entry = absolutePathField(record.entry);
+  if (record.kind !== "source" || entry === null) return null;
+  return {
+    kind: "source",
+    runtime,
+    runtimeArgs,
+    entry,
+    rtk: absolutePathField(record.rtk),
+    checkoutRoot: absolutePathField(record.checkoutRoot),
+    bundle: bundleField(record.bundle),
+  };
+}
+function parseHookLaneDescriptor(stdout) {
+  const record = parseJsonRecord(stdout);
+  if (record === null) return null;
+  const runtime = absolutePathField(record.runtime);
+  const runtimeArgs = runtimeArgsField(record.runtimeArgs);
+  if (runtime === null || runtimeArgs === null) return null;
+  if (record.kind !== "compiled") return sourceLane(record, runtime, runtimeArgs);
+  if (runtimeArgs.length > 0) return null;
+  return {
+    kind: "compiled",
+    runtime,
+    runtimeArgs: [],
+    entry: null,
+    rtk: absolutePathField(record.rtk),
+  };
+}
+function hookLaneSpawnArgs(lane, hookName, bundled = false) {
+  if (lane.kind === "compiled") return ["hook", hookName];
+  const script = bundled && lane.bundle !== null ? lane.bundle.run : lane.entry;
+  return [...lane.runtimeArgs, script, hookName];
+}
+function sourceNodePath(checkoutRoot, inherited) {
+  const required = [
+    join(checkoutRoot, "node_modules"),
+    join(checkoutRoot, "node_modules", ".pnpm", "node_modules"),
+  ];
+  const existing = (inherited ?? "").split(delimiter).filter((entry) => entry.length > 0);
+  return [...new Set([...required, ...existing])].join(delimiter);
+}
+function laneSpawn({ lane, bundled }, directory, hookName, signal) {
+  const env = hookEnv(directory);
+  if (env[SKIP_UPDATE_CHECK_ENV] === undefined || env[SKIP_UPDATE_CHECK_ENV] === "") {
+    env[SKIP_UPDATE_CHECK_ENV] = "1";
+  }
+  env[HOOK_OWNER_PID_ENV] = String(process.pid);
+  if (lane.kind === "source" && lane.checkoutRoot !== null) {
+    env.NODE_PATH = sourceNodePath(lane.checkoutRoot, env.NODE_PATH);
+  }
+  return {
+    command: lane.runtime,
+    args: hookLaneSpawnArgs(lane, hookName, bundled),
+    env,
+    group: true,
+    ...(signal === undefined ? {} : { signal }),
+  };
+}
+function isRegularFile(candidate) {
+  try {
+    return statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function laneTargetsExist(lane) {
+  return isExecutableFile(lane.runtime) && (lane.entry === null || isRegularFile(lane.entry));
+}
+var NO_LANE_USAGE = /Usage: hook-entrypoint <hook-name>|Unknown hook "lane"|unknown hook: lane/u;
+var MAX_REASON_CHARS = 200;
+function laneAnswerOf(result) {
+  if (result.exitCode === 0) {
+    const lane = parseHookLaneDescriptor(result.stdout.toString().trim());
+    if (lane === null) return { kind: "none", reason: "unrecognized lane report" };
+    if (laneTargetsExist(lane)) return { kind: "lane", lane };
+    return { kind: "transient", reason: "lane runtime or entry is missing" };
+  }
+  const stderr = result.stderr.toString().replace(/\s+/gu, " ").trim().slice(0, MAX_REASON_CHARS);
+  if (result.exitCode !== null && NO_LANE_USAGE.test(stderr)) {
+    return { kind: "none", reason: "runtime predates `wp hook lane`" };
+  }
+  const status = result.exitCode === null ? "did not complete" : `exit ${result.exitCode}`;
+  return { kind: "transient", reason: stderr === "" ? status : `${status}: ${stderr}` };
+}
+async function resolveHookLane(directory, signal) {
+  if (process.platform === "win32") return { kind: "none", reason: "no process groups" };
+  let launcher;
+  try {
+    launcher = resolveWpHookCommand();
+  } catch (error) {
+    return { kind: "transient", reason: messageOf(error) };
+  }
+  const spec = {
+    ...launcherSpawn(launcher, directory, HOOK_LANE_ARGS),
+    group: true,
+    signal,
+  };
+  return laneAnswerOf(await spawnHookProcess(spec, directory, ""));
+}
+var HOOK_BUNDLE_HOST = { statSync, readFileSync, isAbsolute };
+function evictOldest(map, max) {
+  while (map.size > max) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined) break;
+    map.delete(oldest);
+  }
 }
 
+class HookLaneCache {
+  entries = new Map();
+  manifests = new Map();
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  laneFor(directory) {
+    const entry = this.entryFor(directory);
+    const lane = this.liveLane(entry, directory);
+    if (lane === null) return null;
+    if (lane.kind !== "source" || lane.bundle === null) return { lane, bundled: false };
+    if (this.isBundleFresh(lane.bundle)) return { lane, bundled: true };
+    this.refresh(entry, directory);
+    return { lane, bundled: false };
+  }
+  rtkFor(directory) {
+    return this.entries.get(directory)?.lane?.rtk ?? null;
+  }
+  drop(directory, lane, reason) {
+    const entry = this.entries.get(directory);
+    if (entry === undefined || entry.lane !== lane) return;
+    entry.lane = null;
+    this.options.debug(
+      `hook lane ${directory}: could not start ${lane.runtime} (${reason}); using the launcher`,
+    );
+  }
+  liveLane(entry, directory) {
+    if (entry.lane !== null && !laneTargetsExist(entry.lane)) {
+      entry.lane = null;
+      this.options.debug(`hook lane ${directory}: runtime or entry vanished; using the launcher`);
+    }
+    if (entry.lane === null) this.refresh(entry, directory);
+    return entry.lane;
+  }
+  refresh(entry, directory) {
+    const now = this.options.now();
+    if (entry.final || entry.inFlight || now < entry.nextAttemptMs) return;
+    if (this.options.signal.aborted) return;
+    entry.inFlight = true;
+    entry.nextAttemptMs = now + HOOK_LANE_REFRESH_INTERVAL_MS;
+    resolveHookLane(directory, this.options.signal)
+      .catch((error) => ({ kind: "transient", reason: messageOf(error) }))
+      .then((answer) => this.settle(entry, directory, answer))
+      .catch(() => {});
+  }
+  settle(entry, directory, answer) {
+    entry.inFlight = false;
+    if (answer.kind === "lane") {
+      entry.lane = answer.lane;
+      this.options.debug(`hook lane ${directory}: settled ${answer.lane.kind} lane`);
+      return;
+    }
+    if (answer.kind === "none") {
+      entry.lane = null;
+      entry.final = true;
+      this.options.debug(`hook lane ${directory}: settled no lane (${answer.reason})`);
+      return;
+    }
+    entry.nextAttemptMs = this.options.now() + HOOK_LANE_RETRY_COOLDOWN_MS;
+    this.options.debug(
+      `hook lane ${directory}: settled transient failure, retry after ${HOOK_LANE_RETRY_COOLDOWN_MS} ms (${answer.reason})`,
+    );
+  }
+  isBundleFresh(bundle) {
+    const manifest = this.manifestOf(bundle.manifest);
+    return manifest !== null && isHookBundleManifestFresh(HOOK_BUNDLE_HOST, manifest);
+  }
+  manifestOf(path) {
+    const cached = this.manifests.get(path);
+    if (cached !== undefined) return cached;
+    const manifest = readHookBundleManifest(HOOK_BUNDLE_HOST, path);
+    if (manifest === null) return null;
+    this.manifests.set(path, manifest);
+    evictOldest(this.manifests, MAX_CACHED_LANES);
+    return manifest;
+  }
+  entryFor(directory) {
+    const existing = this.entries.get(directory);
+    if (existing !== undefined) return existing;
+    const entry = {
+      lane: null,
+      final: false,
+      inFlight: false,
+      nextAttemptMs: Number.NEGATIVE_INFINITY,
+    };
+    this.entries.set(directory, entry);
+    evictOldest(this.entries, MAX_CACHED_LANES);
+    return entry;
+  }
+}
+function hookFailure(hookName, detail, cause) {
+  return new Error(
+    `GUARD_PRETOOL_FAILURE: webpresso hook ${hookName} ${detail}`,
+    cause === undefined ? undefined : { cause },
+  );
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function extractAdditionalContext(envelope) {
+  const context = envelope?.hookSpecificOutput?.additionalContext;
+  return typeof context === "string" ? context : null;
+}
 function extractDenyReason(envelope) {
   const output = envelope?.hookSpecificOutput;
   if (output?.permissionDecision === "deny") {
-    return output.permissionDecisionReason ?? "webpresso denied this tool call";
+    const reason = output.permissionDecisionReason;
+    return typeof reason === "string" && reason.length > 0 ? reason : DEFAULT_DENY_REASON;
   }
-
   return null;
 }
-
-function extractUpdatedInput(envelope) {
+function extractUpdatedCommand(envelope) {
   const output = envelope?.hookSpecificOutput;
-  return output?.permissionDecision === "allow" ? (output.updatedInput ?? null) : null;
+  if (output?.permissionDecision !== "allow") return null;
+  const updatedInput = output.updatedInput;
+  if (typeof updatedInput !== "object" || updatedInput === null || Array.isArray(updatedInput)) {
+    return null;
+  }
+  const command = updatedInput.command;
+  return typeof command === "string" ? command : null;
 }
-
-function hookInputForTool(tool, args, directory) {
-  const toolArgs = args && typeof args === "object" && !Array.isArray(args) ? args : {};
+function interpretHookResult(hookName, result, required) {
+  const stdout = result.stdout.toString().trim();
+  const stderr = result.stderr.toString().trim();
+  const detail = stderr === "" ? "" : `: ${stderr}`;
+  if (result.exitCode !== 0) {
+    if (!required) return null;
+    throw hookFailure(
+      hookName,
+      result.exitCode === null
+        ? `did not complete${detail}`
+        : `failed with exit ${result.exitCode}${detail}`,
+    );
+  }
+  if (stdout === "") {
+    if (required) throw hookFailure(hookName, "produced no JSON response");
+    return null;
+  }
+  return parseHookEnvelope(hookName, stdout, detail, required);
+}
+function parseHookEnvelope(hookName, stdout, detail, required) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch (error) {
+    if (required) throw hookFailure(hookName, `produced invalid JSON${detail}`, error);
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    if (required) throw hookFailure(hookName, "produced an invalid JSON envelope");
+    return null;
+  }
+  return parsed;
+}
+async function runOnLauncher(directory, hookName, stdinPayload, required) {
+  let spawnSpec;
+  try {
+    spawnSpec = launcherSpawn(resolveWpHookCommand(), directory, ["hook", hookName]);
+  } catch (error) {
+    if (required) throw hookFailure(hookName, `cannot start: ${messageOf(error)}`, error);
+    return null;
+  }
+  const result = await spawnHookProcess(spawnSpec, directory, stdinPayload);
+  return interpretHookResult(hookName, result, required);
+}
+function createWpHookRunner(signal, lanes) {
+  return async (directory, hookName, payload, options = {}) => {
+    const required = options.required === true;
+    const stdinPayload = payload === null ? "" : JSON.stringify(payload);
+    const selected = lanes.laneFor(directory);
+    if (selected !== null) {
+      const spec = laneSpawn(selected, directory, hookName, signal);
+      const result = await spawnHookProcess(spec, directory, stdinPayload);
+      if (result.notStarted !== true) return interpretHookResult(hookName, result, required);
+      lanes.drop(directory, selected.lane, result.stderr.toString());
+    }
+    return runOnLauncher(directory, hookName, stdinPayload, required);
+  };
+}
+var OPENCODE_TOOL_NAME_ALIASES = {
+  bash: "shell",
+  ash: "shell",
+  ash_command: "shell",
+};
+function canonicalToolName(tool) {
+  if (typeof tool !== "string") return tool;
+  return Object.hasOwn(OPENCODE_TOOL_NAME_ALIASES, tool) ? OPENCODE_TOOL_NAME_ALIASES[tool] : tool;
+}
+function hookInputForTool(tool, input, directory, sessionId, hookEventName) {
+  const toolInput =
+    typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
   const base = {
     cwd: directory,
-    hook_event_name: "PreToolUse",
+    hook_event_name: hookEventName,
+    ...(sessionId === null ? {} : { session_id: sessionId }),
   };
-
   switch (tool) {
-    case "bash":
+    case "shell":
       return {
         ...base,
         tool_name: "Bash",
         tool_input: {
-          ...toolArgs,
-          command: toolArgs.command ?? "",
+          ...toolInput,
+          command: typeof toolInput.command === "string" ? toolInput.command : "",
         },
       };
     case "write":
@@ -46,8 +809,8 @@ function hookInputForTool(tool, args, directory) {
         ...base,
         tool_name: "Write",
         tool_input: {
-          file_path: args?.filePath ?? "",
-          content: args?.content ?? "",
+          file_path: stringField(toolInput.path),
+          content: stringField(toolInput.content),
         },
       };
     case "edit":
@@ -55,196 +818,476 @@ function hookInputForTool(tool, args, directory) {
         ...base,
         tool_name: "Edit",
         tool_input: {
-          file_path: args?.filePath ?? "",
-          old_string: args?.oldString ?? "",
-          new_string: args?.newString ?? "",
+          file_path: stringField(toolInput.path),
+          old_string: stringField(toolInput.oldString),
+          new_string: stringField(toolInput.newString),
         },
       };
     case "read":
       return {
         ...base,
         tool_name: "Read",
-        tool_input: {
-          file_path: args?.filePath ?? "",
-        },
+        tool_input: { file_path: stringField(toolInput.path) },
       };
-    case "apply_patch":
+    case "patch":
       return {
         ...base,
-        tool_name: "Write",
-        tool_input: {
-          patch_text: args?.patchText ?? "",
-        },
+        tool_name: "apply_patch",
+        tool_input: { patch_text: stringField(toolInput.patchText) },
       };
     default:
       return null;
   }
 }
-
-function shellQuote(value) {
-  return `'${String(value).replaceAll("'", "'\\''")}'`;
+function stringField(value) {
+  return typeof value === "string" ? value : "";
 }
-
-function isExecutableFile(candidate) {
-  try {
-    const stat = statSync(candidate);
-    if (!stat.isFile()) return false;
-    if (process.platform !== "win32") accessSync(candidate, constants.X_OK);
-    return true;
-  } catch {
-    return false;
+function sessionIdFrom(source) {
+  if (typeof source !== "object" || source === null) return null;
+  const record = source;
+  const candidate = record.sessionID ?? record.sessionId ?? record.session_id;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : null;
+}
+var pinnedContextMatches = (ctx) => ctx;
+function applyModelCeilings(editor) {
+  for (const { providerID, id, limit } of editor.list()) {
+    const ceiling = ceilingFor(limit);
+    if (ceiling === null || typeof providerID !== "string" || typeof id !== "string") continue;
+    editor.update(providerID, id, (draft) => {
+      draft.limit.input = ceiling;
+    });
   }
 }
-
-function fixedAppWpLauncher() {
-  const home =
-    process.platform === "win32"
-      ? process.env.USERPROFILE || homedir()
-      : process.env.HOME || homedir();
-  return process.platform === "win32"
-    ? join(home, ".webpresso", "bin", "wp.exe")
-    : join(home, ".webpresso", "bin", "wp");
+function applyGeneralSteps(editor) {
+  const general = editor.get("general");
+  if (general === undefined) return;
+  const steps = stepsFor(general.steps);
+  if (steps === null) return;
+  editor.update("general", (draft) => {
+    draft.steps = steps;
+  });
 }
-
-async function resolveWpHookCommand($, directory, hookName) {
-  const explicit = process.env.WEBPRESSO_WP_BIN;
-  const jitRoot = process.env.WP_FORCE_JIT_PATH;
-  if (explicit && jitRoot) {
-    throw new Error("WEBPRESSO_WP_BIN and WP_FORCE_JIT_PATH are both set; unset one.");
+async function registerSessionBudget(host, registrations, debug) {
+  if (host.options?.sessionBudget === false) return;
+  const model = host.model;
+  const agent = host.agent;
+  if (typeof model?.transform !== "function" || typeof agent?.transform !== "function") {
+    debug("session budget: the host has no model.transform/agent.transform; skipped");
+    return;
   }
-
-  let candidate = null;
-  let label = "Webpresso app launcher";
-  if (explicit) {
-    candidate = explicit;
-    label = "WEBPRESSO_WP_BIN";
-  } else if (jitRoot) {
-    candidate = join(jitRoot, "bin", "wp");
-    label = "WP_FORCE_JIT_PATH";
-  } else {
-    candidate = fixedAppWpLauncher();
+  try {
+    registrations.push(await model.transform(applyModelCeilings));
+    registrations.push(await agent.transform(applyGeneralSteps));
+  } catch (error) {
+    debug(`session budget: transform registration failed (${messageOf(error)}); hooks unaffected`);
   }
-
-  if (!isExecutableFile(candidate)) {
-    throw new Error(
-      `${label} points to ${candidate}, but that executable is not available. ` +
-        "Set WEBPRESSO_WP_BIN, set WP_FORCE_JIT_PATH to an agent-kit checkout, or install the Webpresso app.",
+}
+async function sessionDirectoryOf(session, sessionID) {
+  if (sessionID === null) throw new Error("no session id on tool event");
+  let info;
+  try {
+    info = await withDeadline(
+      session.get({ sessionID }),
+      SESSION_LOOKUP_TIMEOUT_MS,
+      `session lookup exceeded ${SESSION_LOOKUP_TIMEOUT_MS} ms`,
     );
+  } catch (error) {
+    throw new Error(`session lookup failed: ${messageOf(error)}`);
+  }
+  const directory = info?.location?.directory;
+  if (typeof directory !== "string" || directory.length === 0) {
+    throw new Error(`session lookup failed: no location.directory for session ${sessionID}`);
   }
-  return `${shellQuote(candidate)} hook ${hookName}`;
+  return directory;
+}
+function withDeadline(pending, timeoutMs, message) {
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([pending, deadline]).finally(() => {
+    if (timer !== undefined) clearTimeout(timer);
+  });
+}
+function workdirAnchor(sessionDirectory, input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return sessionDirectory;
+  const workdir = input.workdir;
+  if (typeof workdir !== "string" || workdir.length === 0) return sessionDirectory;
+  return isAbsolute(workdir) ? workdir : resolve(sessionDirectory, workdir);
 }
 
-async function runHook($, directory, hookName, payload, options = {}) {
-  const stdinPayload = payload === null ? "" : JSON.stringify(payload);
-  const command = await resolveWpHookCommand($, directory, hookName);
-  const result =
-    await $`printf '%s' ${stdinPayload} | env CLAUDE_PROJECT_DIR=${directory} WP_HOOK_HOST=opencode sh -lc ${command}`
-      .cwd(directory)
-      .quiet()
-      .nothrow();
-
-  const stdout = result.stdout.toString().trim();
-  const stderr = result.stderr?.toString().trim() ?? "";
-  const exitCode = result.exitCode ?? 0;
-  const required = options.required === true;
-
-  if (exitCode !== 0) {
-    if (required) {
-      throw new Error(
-        `webpresso hook ${hookName} failed with exit ${exitCode}${stderr ? `: ${stderr}` : ""}`,
-      );
+class SessionContextStore {
+  contexts = new Map();
+  set(sessionId, contexts) {
+    this.contexts.delete(sessionId);
+    this.contexts.set(
+      sessionId,
+      contexts.map((text) => text.slice(0, MAX_CONTEXT_CHARS)),
+    );
+    while (this.contexts.size > MAX_TRACKED_SESSIONS) {
+      const oldest = this.contexts.keys().next().value;
+      if (oldest === undefined) break;
+      this.contexts.delete(oldest);
     }
-    return null;
   }
-
-  if (stdout === "") {
-    if (required) {
-      throw new Error(`webpresso hook ${hookName} produced no JSON response`);
+  get(sessionId) {
+    return this.contexts.get(sessionId) ?? [];
+  }
+  delete(sessionId) {
+    this.contexts.delete(sessionId);
+  }
+  clear() {
+    this.contexts.clear();
+  }
+}
+function isTextPart(part) {
+  if (typeof part !== "object" || part === null) return false;
+  const record = part;
+  return record.type === "text" && typeof record.text === "string";
+}
+function joinedContentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const texts = content.filter(isTextPart);
+  return texts.length === 0 ? null : texts.map((part) => part.text).join("");
+}
+function replaceContentText(content, text) {
+  if (typeof content === "string") return text;
+  if (!Array.isArray(content)) return content;
+  const next = [];
+  let placed = false;
+  for (const part of content) {
+    if (!isTextPart(part)) next.push(part);
+    else if (!placed) {
+      placed = true;
+      next.push({ ...part, text });
     }
-    return null;
   }
-
+  return next;
+}
+function rawOutputRoot(env = process.env, home = homedir()) {
+  const state = env.XDG_STATE_HOME;
+  const base = state !== undefined && isAbsolute(state) ? state : join(home, ".local", "state");
+  return join(base, "webpresso", "opencode-raw-output");
+}
+function ownDirectories(root) {
   try {
-    return JSON.parse(stdout);
-  } catch (error) {
-    if (required) {
-      throw new Error(
-        `webpresso hook ${hookName} produced invalid JSON${stderr ? `: ${stderr}` : ""}`,
-        { cause: error },
-      );
+    return readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => join(root, entry.name));
+  } catch {
+    return [];
+  }
+}
+function removeIfStale(file, cutoffMs) {
+  try {
+    if (statSync(file).mtimeMs >= cutoffMs) return false;
+    unlinkSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneSessionDirectory(directory, cutoffMs, budget) {
+  let removed = 0;
+  try {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (removed >= budget) break;
+      if (entry.isFile() && removeIfStale(join(directory, entry.name), cutoffMs)) removed += 1;
     }
+    rmdirSync(directory);
+  } catch {}
+  return removed;
+}
+function pruneRawOutput(root, nowMs = Date.now()) {
+  const cutoffMs = nowMs - RAW_OUTPUT_MAX_AGE_MS;
+  let removed = 0;
+  for (const directory of ownDirectories(root)) {
+    if (removed >= RAW_OUTPUT_PRUNE_LIMIT) break;
+    removed += pruneSessionDirectory(directory, cutoffMs, RAW_OUTPUT_PRUNE_LIMIT - removed);
+  }
+  return removed;
+}
+function saveRawOutput(root, sessionID, callID, text) {
+  if (!RAW_OUTPUT_SEGMENT.test(sessionID) || !RAW_OUTPUT_SEGMENT.test(callID)) return null;
+  const directory = join(root, sessionID);
+  const file = join(directory, `${callID}.txt`);
+  try {
+    mkdirSync(directory, { recursive: true, mode: RAW_OUTPUT_DIR_MODE });
+    chmodSync(directory, RAW_OUTPUT_DIR_MODE);
+    writeFileSync(file, text, { mode: RAW_OUTPUT_FILE_MODE, flag: "wx" });
+    return file;
+  } catch {
     return null;
   }
 }
-
-async function collectSessionStartContext($, directory) {
-  const contexts = [];
-
-  for (const hookName of SESSION_START_HOOKS) {
-    const envelope = await runHook($, directory, hookName, null);
-    const message = extractAdditionalContext(envelope);
-    if (message === null) {
-      continue;
-    }
-
-    contexts.push(message);
+async function runRtkPipe(rtk, filter, text, directory, signal) {
+  const result = await spawnHookProcess(
+    {
+      command: rtk,
+      args: ["pipe", "--filter", filter],
+      env: { ...process.env },
+      group: true,
+      signal,
+      budgetMs: RTK_PIPE_BUDGET_MS,
+    },
+    directory,
+    text,
+  );
+  if (result.exitCode !== 0 || result.stdout.length >= HOOK_OUTPUT_CAP_BYTES) return null;
+  const filtered = result.stdout.toString();
+  if (filtered.trim() === "") return null;
+  return Buffer.byteLength(filtered) < Buffer.byteLength(text) ? filtered : null;
+}
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function shellFilterTarget(event, tool) {
+  if (tool !== SHELL_TOOL_ID || event.status !== "completed") return null;
+  const command = recordOf(event.input)?.command;
+  const result = recordOf(event.result);
+  if (typeof command !== "string" || result === null) return null;
+  if (recordOf(result.metadata)?.truncated === true) return null;
+  const text = joinedContentText(result.content);
+  if (text === null || Buffer.byteLength(text) < SHELL_FILTER_MIN_BYTES) return null;
+  if (text.includes(RTK_FOOTER_MARKER)) return null;
+  const filter = selectOutputFilter(command);
+  return filter === null ? null : { command, filter, result, text };
+}
+function filteredResultText(filtered, filter, inputBytes, raw) {
+  const body = filtered.endsWith(`
+`)
+    ? filtered
+    : `${filtered}
+`;
+  const outputBytes = Buffer.byteLength(body);
+  return `${body}${RTK_FOOTER_MARKER} --filter ${filter}, ${inputBytes}→${outputBytes} bytes; raw: ${raw}]`;
+}
+function replacedOutput(output, text, replacement) {
+  if (typeof output !== "string") return {};
+  const at = output.indexOf(text);
+  if (at === -1) return {};
+  return { output: `${output.slice(0, at)}${replacement}${output.slice(at + text.length)}` };
+}
+async function filterShellResult(event, tool, directory, deps) {
+  try {
+    const target = shellFilterTarget(event, tool);
+    const sessionID = sessionIdFrom(event);
+    if (target === null || sessionID === null || typeof event.id !== "string") return;
+    const rtk = await deps.resolveRtk(directory);
+    if (rtk === null || target.command.trimStart().startsWith(rtk)) return;
+    const filtered = await runRtkPipe(rtk, target.filter, target.text, directory, deps.signal);
+    if (filtered === null) return;
+    const raw = saveRawOutput(deps.rawRoot, sessionID, event.id, target.text);
+    if (raw === null) return;
+    const inputBytes = Buffer.byteLength(target.text);
+    const replacement = filteredResultText(filtered, target.filter, inputBytes, raw);
+    if (Buffer.byteLength(replacement) >= inputBytes) return;
+    event.result = {
+      ...target.result,
+      content: replaceContentText(target.result.content, replacement),
+      ...replacedOutput(target.result.output, target.text, replacement),
+    };
+  } catch {}
+}
+function defaultDebug(message) {
+  if (process.env[PLUGIN_DEBUG_ENV] === "1") {
+    process.stderr.write(`[${OPENCODE_PLUGIN_ID}] ${message}
+`);
   }
-
-  return contexts;
 }
-
-export const WebpressoHooksPlugin = async ({ $, directory }) => {
-  let cachedSessionContexts = [];
-
+function createWebpressoOpenCodePlugin(deps = {}) {
+  const preToolHookName = PRE_TOOL_HOOKS[0];
+  if (preToolHookName === undefined) {
+    throw new Error("no managed PreToolUse hook in WP_HOOK_SPECS");
+  }
   return {
-    event: async ({ event }) => {
-      if (event?.type === "session.created") {
-        cachedSessionContexts = await collectSessionStartContext($, directory);
-      }
-    },
-    "shell.env": async (input, output) => {
-      output.env.CLAUDE_PROJECT_DIR = input.cwd;
-    },
-    "tool.execute.before": async (input, output) => {
-      const payload = hookInputForTool(input?.tool, output?.args ?? input?.args ?? {}, directory);
-      if (payload === null) {
-        return;
-      }
-
-      for (const hookName of PRE_TOOL_HOOKS) {
-        const envelope = await runHook($, directory, hookName, payload, { required: true });
-        const denyReason = extractDenyReason(envelope);
-        if (denyReason !== null) {
-          throw new Error(denyReason);
-        }
-        const updatedInput = extractUpdatedInput(envelope);
-        const nextCommand = updatedInput?.command;
-        if (input?.tool === "bash" && typeof nextCommand === "string") {
-          output.args.command = nextCommand;
+    id: OPENCODE_PLUGIN_ID,
+    async setup(ctx) {
+      const host = pinnedContextMatches(ctx);
+      const store = new SessionContextStore();
+      const controller = new AbortController();
+      const debug = deps.debug ?? defaultDebug;
+      const lanes = new HookLaneCache({
+        signal: controller.signal,
+        debug,
+        now: deps.now ?? Date.now,
+      });
+      const runHook = deps.runWpHook ?? createWpHookRunner(controller.signal, lanes);
+      const resolveRtk =
+        deps.resolveRtk ??
+        (deps.runWpHook === undefined
+          ? (directory) => Promise.resolve(lanes.rtkFor(directory))
+          : () => Promise.resolve(null));
+      const rawRoot = deps.rawOutputRoot ?? rawOutputRoot();
+      pruneRawOutput(rawRoot);
+      const registrations = [];
+      let cleanedUp = false;
+      const cleanup = async () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        controller.abort();
+        store.clear();
+        await Promise.all(
+          registrations.map(async (registration) => {
+            try {
+              await registration.dispose();
+            } catch {}
+          }),
+        );
+      };
+      const collectSessionStartContexts = async (directory, sessionId) => {
+        const contexts = [];
+        const payload = {
+          cwd: directory,
+          hook_event_name: OPENCODE_HOOK_EVENT_NAMES.sessionStart,
+          session_id: sessionId,
+        };
+        for (const hookName of SESSION_START_HOOKS) {
+          const envelope = await runHook(directory, hookName, payload);
+          const context = extractAdditionalContext(envelope);
+          if (context !== null) contexts.push(context);
         }
-      }
-    },
-    "tool.execute.after": async (input, output) => {
-      const payload = hookInputForTool(input?.tool, output?.args ?? input?.args ?? {}, directory);
-      if (payload === null) {
-        return;
-      }
-
-      for (const hookName of POST_TOOL_HOOKS) {
-        await runHook($, directory, hookName, payload);
-      }
-    },
-    "experimental.session.compacting": async (_input, output) => {
-      cachedSessionContexts = await collectSessionStartContext($, directory);
-      if (output && Array.isArray(output.context)) {
-        for (const message of cachedSessionContexts) {
-          output.context.push(message);
+        return contexts;
+      };
+      const resolveSessionDirectory = async (sessionID) => {
+        try {
+          return await sessionDirectoryOf(host.session, sessionID);
+        } catch (error) {
+          throw hookFailure(preToolHookName, messageOf(error), error);
         }
+      };
+      try {
+        registrations.push(
+          await host.tool.hook(OPENCODE_V2_DOMAIN_HOOKS.toolBefore, async (event) => {
+            event.tool = canonicalToolName(event.tool);
+            const sessionID = sessionIdFrom(event);
+            const sessionDirectory = await resolveSessionDirectory(sessionID);
+            const payload = hookInputForTool(
+              event.tool,
+              event.input,
+              workdirAnchor(sessionDirectory, event.input),
+              sessionID,
+              OPENCODE_HOOK_EVENT_NAMES.preToolUse,
+            );
+            if (payload === null) return;
+            for (const hookName of PRE_TOOL_HOOKS) {
+              const envelope = await runHook(payload.cwd, hookName, payload, { required: true });
+              const denyReason = extractDenyReason(envelope);
+              if (denyReason !== null) throw new Error(denyReason);
+              const updatedCommand = extractUpdatedCommand(envelope);
+              if (event.tool === "shell" && updatedCommand !== null) {
+                const input = event.input;
+                if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+                  input.command = updatedCommand;
+                }
+              }
+            }
+          }),
+        );
+        registrations.push(
+          await host.tool.hook(OPENCODE_V2_DOMAIN_HOOKS.toolAfter, async (event) => {
+            if (event.status === "error") {
+              return;
+            }
+            const tool = canonicalToolName(event.tool);
+            const sessionID = sessionIdFrom(event);
+            let sessionDirectory;
+            try {
+              sessionDirectory = await sessionDirectoryOf(host.session, sessionID);
+            } catch {
+              return;
+            }
+            const payload = hookInputForTool(
+              tool,
+              event.input,
+              workdirAnchor(sessionDirectory, event.input),
+              sessionID,
+              OPENCODE_HOOK_EVENT_NAMES.postToolUse,
+            );
+            if (payload === null) return;
+            for (const hookName of POST_TOOL_HOOKS) {
+              await runHook(payload.cwd, hookName, payload);
+            }
+            await filterShellResult(event, tool, payload.cwd, {
+              resolveRtk,
+              rawRoot,
+              signal: controller.signal,
+            });
+          }),
+        );
+        registrations.push(
+          await host.shell.hook(OPENCODE_V2_DOMAIN_HOOKS.shellBefore, (event) => {
+            event.env[OPENCODE_HOOK_ENV.projectDir] = event.cwd;
+          }),
+        );
+        registrations.push(
+          await host.session.hook(OPENCODE_V2_DOMAIN_HOOKS.sessionCompaction, async (event) => {
+            try {
+              const directory = await sessionDirectoryOf(host.session, event.sessionID);
+              const contexts = await collectSessionStartContexts(directory, event.sessionID);
+              if (contexts.length > 0) store.set(event.sessionID, contexts);
+            } catch {}
+            for (const text of store.get(event.sessionID)) {
+              event.system.push({ type: "text", text });
+            }
+          }),
+        );
+        (async () => {
+          try {
+            for await (const hostEvent of host.event.subscribe({ signal: controller.signal })) {
+              if (typeof hostEvent !== "object" || hostEvent === null) continue;
+              const record = hostEvent;
+              if (typeof record.type !== "string") continue;
+              if (record.type === OPENCODE_V2_SESSION_EVENTS.created) {
+                const data = record.data;
+                if (typeof data !== "object" || data === null) continue;
+                const created = data;
+                const sessionID = sessionIdFrom(created);
+                const directory = created.location?.directory;
+                if (sessionID === null || typeof directory !== "string" || directory === "") {
+                  continue;
+                }
+                store.set(sessionID, await collectSessionStartContexts(directory, sessionID));
+              } else if (record.type === OPENCODE_V2_SESSION_EVENTS.deleted) {
+                const data = record.data;
+                if (typeof data !== "object" || data === null) continue;
+                const sessionID = sessionIdFrom(data);
+                if (sessionID !== null) store.delete(sessionID);
+              }
+            }
+          } catch {}
+        })().catch(() => {});
+        await registerSessionBudget(host, registrations, debug);
+      } catch (error) {
+        await cleanup();
+        throw error;
       }
+      return cleanup;
     },
   };
+}
+var webpressoOpenCodePlugin = createWebpressoOpenCodePlugin();
+var opencode_plugin_default = webpressoOpenCodePlugin;
+export {
+  OPENCODE_HOOK_ENV,
+  OPENCODE_HOOK_EVENT_NAMES,
+  OPENCODE_HOOK_LANE_RUNTIME_ARGS,
+  OPENCODE_HOOK_OWNER_PID_ENV,
+  OPENCODE_MANAGED_HOOK_COMMANDS,
+  OPENCODE_PLUGIN_ID,
+  OPENCODE_TOOL_NAME_ALIASES,
+  OPENCODE_V2_DOMAIN_HOOKS,
+  OPENCODE_V2_SESSION_EVENTS,
+  createWebpressoOpenCodePlugin,
+  opencode_plugin_default as default,
+  hookLaneSpawnArgs,
+  joinedContentText,
+  parseHookLaneDescriptor,
+  pruneRawOutput,
+  rawOutputRoot,
+  replaceContentText,
+  resolveWpLauncher,
+  sweepProcessGroup,
 };
-
-const webpressoOpenCodePlugins = [WebpressoHooksPlugin];
-
-export default webpressoOpenCodePlugins;