@rebon/cli-darwin-arm64 1.8.7 → 1.9.2

package/bin/marketplace/plugins/dsh-web-search-exa/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/marketplace/plugins/dsh-web-search-exa/rebon-plugin.json

@@ -0,0 +1,27 @@
+{
+  "name": "dsh-web-search-exa",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness Exa search backend for web_search (needs an Exa API key). Packaged from the DeepSeek Harness module Rebon vendors (@deepseek-ai/dsh-web-search-exa).",
+  "license": "MIT",
+  "capabilities": {
+    "kernelPlugins": {
+      "dsh-web-search-exa": {
+        "entry": "web-search-exa.js",
+        "services": [
+          "web:search:exa"
+        ],
+        "seats": [
+          "credentials"
+        ]
+      }
+    }
+  },
+  "metadata": {
+    "upstream": "@deepseek-ai/dsh-web-search-exa"
+  },
+  "container": {
+    "network": [
+      "api.exa.ai"
+    ]
+  }
+}

package/bin/marketplace/plugins/dsh-web-search-exa/web-search-exa.js

@@ -0,0 +1,122 @@
+// packages/web/web-search-exa/src/index.ts
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import z from "@deepseek-ai/schemastery";
+
+// packages/web/web-search-exa/src/provider.ts
+import { WebError } from "@deepseek-ai/dsh-web";
+var EXA_PROVIDER_ID = "exa";
+var EXA_DEFAULT_BASE_URL = "https://api.exa.ai";
+var EXA_DEFAULT_SEARCH_TYPE = "auto";
+var EXA_DEFAULT_HIGHLIGHTS_PER_RESULT = 1;
+var USER_AGENT = "deepseek-harness/0.0.1";
+function mapExaResult(result) {
+  const snippet = result.highlights?.find((highlight) => highlight.trim().length > 0);
+  if (snippet === void 0) return void 0;
+  return {
+    url: result.url,
+    ...result.title != null && result.title.length > 0 ? { title: result.title } : {},
+    snippet,
+    ...result.publishedDate != null && result.publishedDate.length > 0 ? { publishedAt: result.publishedDate } : {}
+  };
+}
+function mapExaResponse(response) {
+  const sources = (response.results ?? []).map(mapExaResult).filter((source) => source !== void 0);
+  return { sources, truncated: false };
+}
+var ExaSearchProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = EXA_PROVIDER_ID;
+  available() {
+    return this.options.apiKey.length > 0 && isValidBaseUrl(this.options.baseURL) && isPositiveInteger(this.options.highlightsPerResult) && (this.options.numResults === void 0 || isPositiveInteger(this.options.numResults));
+  }
+  async search(request, signal) {
+    const numResults = request.maxResults ?? this.options.numResults;
+    let response;
+    try {
+      response = await fetch(`${this.options.baseURL}/search`, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          "authorization": `Bearer ${this.options.apiKey}`,
+          "content-type": "application/json",
+          "accept": "application/json",
+          "user-agent": USER_AGENT
+        },
+        body: JSON.stringify({
+          query: request.query,
+          type: this.options.searchType,
+          contents: { highlights: { highlightsPerUrl: this.options.highlightsPerResult } },
+          ...numResults !== void 0 ? { numResults } : {}
+        }),
+        ...signal !== void 0 ? { signal } : {}
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      throw new WebError(`Exa search request failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+    if (!response.ok) {
+      const status = response.status;
+      let message = `Exa API error (HTTP ${status})`;
+      try {
+        const parsed = await response.json();
+        const detail = parsed.error ?? parsed.message;
+        if (detail !== void 0 && detail.length > 0) message = detail;
+      } catch (error) {
+        if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      }
+      throw new WebError(message, "WEB_PROVIDER_ERROR");
+    }
+    try {
+      const payload = await response.json();
+      return mapExaResponse(payload);
+    } catch (error) {
+      if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      throw new WebError(`Exa returned an unprocessable response body: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+  }
+};
+function isValidBaseUrl(baseURL) {
+  return URL.canParse(baseURL);
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
+// packages/web/web-search-exa/src/index.ts
+var name = "web-search-exa";
+var inject = ["web"];
+var Config = z.object({
+  apiKey: z.string(),
+  baseURL: z.string(),
+  searchType: z.union(["auto", "keyword", "neural"]),
+  numResults: z.number().step(1).min(1),
+  highlightsPerResult: z.number().step(1).min(1)
+});
+function apply(ctx, config) {
+  ctx.web.registerSearchProvider(new ExaSearchProvider({
+    // Every environment layer may name this key: the product trusts the
+    // project it is launched in, and the managed store is not involved here.
+    apiKey: config.apiKey ?? launchEnvironmentOf(ctx).get("EXA_API_KEY")?.value ?? "",
+    baseURL: config.baseURL ?? EXA_DEFAULT_BASE_URL,
+    searchType: config.searchType ?? EXA_DEFAULT_SEARCH_TYPE,
+    highlightsPerResult: config.highlightsPerResult ?? EXA_DEFAULT_HIGHLIGHTS_PER_RESULT,
+    ...config.numResults !== void 0 ? { numResults: config.numResults } : {}
+  }));
+}
+export {
+  Config,
+  EXA_DEFAULT_BASE_URL,
+  EXA_DEFAULT_HIGHLIGHTS_PER_RESULT,
+  EXA_DEFAULT_SEARCH_TYPE,
+  EXA_PROVIDER_ID,
+  ExaSearchProvider,
+  apply,
+  inject,
+  name
+};

package/bin/mods-runtime/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@rebon/mods-runtime",
+  "version": "0.0.0-private",
+  "private": true,
+  "type": "module",
+  "license": "Apache-2.0",
+  "engines": { "node": ">=24.19.0 <25" },
+  "scripts": { "test": "node --test test/*.test.mjs" },
+  "exports": {
+    ".": "./src/index.mjs",
+    "./claude-code": "./src/claude-code.mjs"
+  }
+}

package/bin/mods-runtime/src/chain.mjs

@@ -0,0 +1,188 @@
+// The hook chain: what `on(event, matcher?, hook)` builds and what a
+// dispatch runs through it.
+//
+// Every hook is `($, e, next)`. `next(e)` runs the hooks beneath and then
+// the engine's own behaviour (`core`), resolving to the event's result. A
+// hook that returns without calling `next` answers for itself; one that
+// calls `next({ ...e, x })` rewrites what the rest sees; one that returns
+// nothing after calling `next` leaves the answer from beneath as it is.
+//
+// A hook that throws or runs out of its budget is skipped and the chain
+// continues without it, unless its registration's `.catch` handler answers
+// in its place — the rule the mods reference states, and the one that keeps
+// a broken mod from blocking a prompt. The failure is reported through
+// `onFailure` so the host can write it to the debug log under the mod's name.
+
+const DEFAULT_BUDGET_MS = 15_000;
+
+/// Whether `pattern` (an event name, `*`, `ns.*` or `!name`) selects `event`.
+export function patternSelects(pattern, event) {
+  if (pattern === '*') return !event.startsWith('telemetry.');
+  if (pattern.startsWith('!')) {
+    const excluded = pattern.slice(1);
+    if (event.startsWith('telemetry.')) return false;
+    return !patternSelects(excluded, event);
+  }
+  if (pattern.endsWith('.*')) return event.startsWith(pattern.slice(0, -1));
+  return pattern === event;
+}
+
+/// Whether a matcher selects a value: a literal by equality, a RegExp by
+/// test, a list by any member, an object by every key, an array value by
+/// any item.
+export function matcherSelects(matcher, value) {
+  if (matcher === undefined) return true;
+  if (matcher instanceof RegExp) return typeof value === 'string' && matcher.test(value);
+  if (Array.isArray(matcher)) return matcher.some((alternative) => matcherSelects(alternative, value));
+  if (Array.isArray(value)) return value.some((item) => matcherSelects(matcher, item));
+  if (matcher !== null && typeof matcher === 'object') {
+    if (value === null || typeof value !== 'object') return false;
+    return Object.keys(matcher).every((key) => matcherSelects(matcher[key], value[key]));
+  }
+  return matcher === value;
+}
+
+/// What `on()` returns: the registration, with `.catch` for a fallback.
+class Registration {
+  constructor(entry) { this.entry = entry; }
+  catch(handler) {
+    if (typeof handler !== 'function') throw new TypeError('.catch() takes a function');
+    this.entry.catchHandler = handler;
+    return this;
+  }
+}
+
+export class HookChain {
+  #entries = [];
+  #sequence = 0;
+  constructor({ onFailure } = {}) {
+    this.onFailure = onFailure ?? (() => {});
+  }
+
+  /// `on(pattern, hook)` or `on(pattern, matcher, hook)`.
+  on(pattern, matcherOrHook, maybeHook) {
+    if (typeof pattern !== 'string' || pattern.length === 0) throw new TypeError('on() needs an event pattern');
+    const hook = maybeHook === undefined ? matcherOrHook : maybeHook;
+    const matcher = maybeHook === undefined ? undefined : matcherOrHook;
+    if (typeof hook !== 'function') throw new TypeError(`on(${JSON.stringify(pattern)}) needs a hook function`);
+    if (matcher !== undefined && (matcher === null || typeof matcher !== 'object')) {
+      throw new TypeError(`on(${JSON.stringify(pattern)}) takes a matcher object before the hook`);
+    }
+    const entry = { id: ++this.#sequence, pattern, matcher, hook, catchHandler: undefined };
+    this.#entries.push(entry);
+    return new Registration(entry);
+  }
+
+  /// The patterns registered, in registration order, each once.
+  patterns() {
+    const seen = new Set();
+    const out = [];
+    for (const entry of this.#entries) {
+      if (seen.has(entry.pattern)) continue;
+      seen.add(entry.pattern);
+      out.push(entry.pattern);
+    }
+    return out;
+  }
+
+  /// Whether any registration could select `event` (matchers aside).
+  listens(event) {
+    return this.#entries.some((entry) => patternSelects(entry.pattern, event));
+  }
+
+  /// The registrations whose pattern selects `event`. Their matchers are
+  /// tested per hook at dispatch, against the event as the hooks above
+  /// left it: a rewrite upstream is what a matcher downstream sees.
+  hooksFor(event) {
+    return this.#entries.filter((entry) => patternSelects(entry.pattern, event));
+  }
+
+  /// Runs `event` through the hooks that select it, `core` beneath them.
+  ///
+  /// `core(e)` is the engine's own behaviour for the event as the chain left
+  /// `e`; it is called at most once. The resolved value is the event's result.
+  async dispatch(event, input, core, options = {}) {
+    const hooks = this.hooksFor(event);
+    const budgetMs = options.budgetMs ?? DEFAULT_BUDGET_MS;
+    const engine = options.engine;
+    const started = Date.now();
+    const controller = new AbortController();
+    if (options.signal) options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+    const remaining = () => Math.max(0, budgetMs - (Date.now() - started));
+    const dispatchState = { reachedCore: false, coreInput: undefined };
+
+    const run = async (index, current) => {
+      if (index >= hooks.length) {
+        dispatchState.reachedCore = true;
+        dispatchState.coreInput = current;
+        return core(current);
+      }
+      const entry = hooks[index];
+      if (!matcherSelects(entry.matcher, current)) return run(index + 1, current);
+      let nextCalled = false;
+      let beneath;
+      const next = (rewritten = current) => {
+        if (nextCalled) return beneath;
+        nextCalled = true;
+        beneath = run(index + 1, rewritten);
+        return beneath;
+      };
+      next.signal = controller.signal;
+      next.budget = () => remaining();
+      next.origin = options.origin;
+      const frozen = freezeDeep(current);
+      try {
+        const answer = await withBudget(entry.hook(engine, frozen, next), remaining(), controller);
+        if (answer !== undefined) return answer;
+        if (nextCalled) return await beneath;
+        return run(index + 1, current);
+      } catch (error) {
+        this.onFailure({ event, pattern: entry.pattern, error });
+        if (entry.catchHandler) {
+          const caught = Object.assign((rewritten = current) => next(rewritten), next, {
+            error,
+            cause: error,
+          });
+          try {
+            const answer = await withBudget(entry.catchHandler(engine, frozen, caught), remaining(), controller);
+            if (answer !== undefined) return answer;
+          } catch (second) {
+            this.onFailure({ event, pattern: entry.pattern, error: second, inCatch: true });
+          }
+        }
+        if (nextCalled) return await beneath;
+        return run(index + 1, current);
+      }
+    };
+    const result = await run(0, input);
+    return { result, reachedCore: dispatchState.reachedCore, coreInput: dispatchState.coreInput };
+  }
+}
+
+async function withBudget(pending, ms, controller) {
+  if (!(pending instanceof Promise)) return pending;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`[HOOK_BUDGET] the hook did not answer within ${ms}ms`));
+    }, ms);
+  });
+  try {
+    return await Promise.race([pending, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/// A frozen copy of a plain value, so a hook reads `e` and cannot write it.
+export function freezeDeep(value) {
+  if (value === null || typeof value !== 'object') return value;
+  if (Object.isFrozen(value)) return value;
+  if (Array.isArray(value)) return Object.freeze(value.map(freezeDeep));
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = freezeDeep(value[key]);
+  return Object.freeze(out);
+}

package/bin/mods-runtime/src/classic.mjs

@@ -0,0 +1,217 @@
+// Rebon's hook events, as a mod's native events and as `classic.<Event>`.
+//
+// Rebon raises the Claude Code settings-hook events (`PreToolUse`,
+// `UserPromptSubmit`, `Stop`, ...) through its policy seat; the `mods`
+// subscriber hands each one here as `{ event, input }`, `input` being what a
+// settings hook would read on stdin. Two things happen with it:
+//
+// 1. The native event the mods reference maps it to fires through the
+//    chain — `tool.call` for PreToolUse, `prompt.submit` for
+//    UserPromptSubmit, `turn.complete` for Stop, and so on — and what the
+//    chain answered is written back as a settings hook's JSON output, the
+//    one vocabulary Rebon's hook runtime projects into effects.
+// 2. `classic.<Event>` fires with the stdin shape itself, and a hook's
+//    return value is that JSON output, passed through as written.
+//
+// The answer is a list of such outputs. Rebon parses each one exactly as
+// it parses a command hook's stdout, aggregates them and projects the
+// effects, so a mod can do precisely what a settings hook can do, and the
+// mapping below is the whole statement of what a native answer means.
+//
+// `tool.call` spans two of Rebon's events. The hook calls `next(e)` for the
+// result, and the result arrives with PostToolUse: the chain is suspended at
+// its core until then, and the PreToolUse answer is given the moment the
+// chain reaches core (the rewritten input) or returns without it (a deny).
+
+const PENDING_CALL_TTL_MS = 10 * 60 * 1000;
+
+const NATIVE_OF = Object.freeze({
+  PreToolUse: 'tool.call',
+  PostToolUse: 'tool.call',
+  PostToolUseFailure: 'tool.call',
+  PermissionDenied: 'tool.call',
+  PermissionRequest: 'tool.check',
+  UserPromptSubmit: 'prompt.submit',
+  Stop: 'turn.complete',
+  PreCompact: 'session.compact',
+  SessionEnd: 'session.end',
+});
+
+/// The native event a classic one maps to, when it maps to one.
+export function nativeEventOf(classic) {
+  return NATIVE_OF[classic];
+}
+
+/// The classic events a chain with these patterns would want to hear.
+export function classicEventsOf(chain, allEvents) {
+  return allEvents.filter((event) => {
+    if (chain.listens(`classic.${event}`)) return true;
+    const native = NATIVE_OF[event];
+    return native !== undefined && chain.listens(native);
+  });
+}
+
+function plain(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+/// Runs one classic event through `mod`'s chain and answers the outputs.
+export async function dispatchClassic(mod, { event, input }) {
+  const outputs = [];
+  const native = NATIVE_OF[event];
+  if (native !== undefined && mod.chain.listens(native)) {
+    const output = await dispatchNative(mod, event, input);
+    if (output !== undefined) outputs.push(output);
+  }
+  const classic = `classic.${event}`;
+  if (mod.chain.listens(classic)) {
+    const { result, reachedCore } = await mod.chain.dispatch(classic, input, async () => ({}), mod.dispatchOptions());
+    if (plain(result) && !(reachedCore && Object.keys(result).length === 0)) outputs.push(result);
+  }
+  return { outputs };
+}
+
+async function dispatchNative(mod, event, input) {
+  switch (event) {
+    case 'PreToolUse': return preToolUse(mod, input);
+    case 'PostToolUse': return settleToolCall(mod, input.tool_use_id, { result: input.tool_response, isError: false }, 'PostToolUse');
+    case 'PostToolUseFailure': return settleToolCall(mod, input.tool_use_id, { result: { error: input.error }, isError: true, text: input.error }, 'PostToolUseFailure');
+    case 'PermissionDenied': return settleToolCall(mod, input.tool_use_id, { result: { error: input.message ?? 'permission denied' }, isError: true, deny: input.message ?? 'permission denied' }, undefined);
+    case 'PermissionRequest': return toolCheck(mod, input);
+    case 'UserPromptSubmit': return promptSubmit(mod, input);
+    case 'Stop': return turnComplete(mod, input);
+    case 'PreCompact': return sessionCompact(mod, input);
+    case 'SessionEnd': {
+      await mod.chain.dispatch('session.end', { reason: input.reason ?? 'other', resume: {} }, async () => ({ sessionId: input.session_id }), mod.dispatchOptions());
+      return undefined;
+    }
+    default: return undefined;
+  }
+}
+
+/// PreToolUse → `tool.call`: the chain runs until it reaches core or
+/// answers; core parks until the tool's result arrives.
+async function preToolUse(mod, input) {
+  const e = {
+    tool: input.tool_name,
+    tool_use_id: input.tool_use_id,
+    input: input.tool_input ?? {},
+    agentId: input.agent_id,
+    origin: { kind: 'model' },
+  };
+  let settle;
+  const parked = new Promise((resolve) => { settle = resolve; });
+  let reportPre;
+  const preAnswered = new Promise((resolve) => { reportPre = resolve; });
+  const core = (final) => {
+    reportPre({ continued: true, input: final.input });
+    return parked;
+  };
+  const whole = mod.chain.dispatch('tool.call', e, core, mod.dispatchOptions({ budgetMs: PENDING_CALL_TTL_MS }))
+    .then((outcome) => { reportPre({ continued: false, outcome }); return outcome; })
+    .catch((error) => { mod.report('tool.call', error); reportPre({ continued: false, outcome: { result: undefined } }); return { result: undefined }; });
+  const pre = await preAnswered;
+  if (pre.continued) {
+    const expiry = setTimeout(() => mod.pendingCalls.delete(input.tool_use_id), PENDING_CALL_TTL_MS);
+    mod.pendingCalls.set(input.tool_use_id, { settle, whole, expiry, coreResult: undefined });
+    if (!sameJson(pre.input, e.input) && plain(pre.input)) {
+      return { hookSpecificOutput: { hookEventName: 'PreToolUse', updatedInput: pre.input } };
+    }
+    return undefined;
+  }
+  const answer = pre.outcome?.result;
+  if (plain(answer) && typeof answer.deny === 'string') {
+    return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: answer.deny } };
+  }
+  if (plain(answer) && 'result' in answer) {
+    // A mod answered the call itself. Rebon's hook model has no way to hand
+    // the model a result without running the tool, so the call goes on and
+    // the mod's answer is reported where the person can read why.
+    mod.log(`tool.call for ${e.tool} was answered by the mod; Rebon runs the tool anyway`, 'debug');
+  }
+  return undefined;
+}
+
+/// PostToolUse / PostToolUseFailure / PermissionDenied → the parked
+/// `tool.call` core resolves and the hook's final answer is read.
+async function settleToolCall(mod, toolUseId, coreResult, eventName) {
+  const pending = mod.pendingCalls.get(toolUseId);
+  if (!pending) return undefined;
+  mod.pendingCalls.delete(toolUseId);
+  clearTimeout(pending.expiry);
+  pending.settle(coreResult);
+  const outcome = await pending.whole;
+  const answer = outcome?.result;
+  if (eventName === undefined || !plain(answer)) return undefined;
+  const output = { hookEventName: eventName };
+  let any = false;
+  if (eventName === 'PostToolUse' && 'result' in answer && !sameJson(answer.result, coreResult.result)) {
+    output.updatedMCPToolOutput = answer.result;
+    any = true;
+  }
+  if (typeof answer.context === 'string' && answer.context.length > 0) {
+    output.additionalContext = answer.context;
+    any = true;
+  }
+  return any ? { hookSpecificOutput: output } : undefined;
+}
+
+/// PermissionRequest → `tool.check`: `{ decision }` becomes the request's
+/// answer; `ask` leaves the prompt to the person.
+async function toolCheck(mod, input) {
+  const e = { tool: input.tool_name, tool_use_id: input.tool_use_id, input: input.tool_input ?? {}, reason: input.reason };
+  const { result } = await mod.chain.dispatch('tool.check', e, async () => ({ decision: 'ask' }), mod.dispatchOptions());
+  if (!plain(result)) return undefined;
+  if (result.decision === 'allow') {
+    return { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'allow' } } };
+  }
+  if (result.decision === 'deny') {
+    return { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny', message: result.reason ?? 'denied by a mod' } } };
+  }
+  return undefined;
+}
+
+/// UserPromptSubmit → `prompt.submit`: a rewrite replaces the prompt, a
+/// `drop` refuses it, `context` rides along as additional context.
+async function promptSubmit(mod, input) {
+  const e = { text: input.prompt ?? '', origin: { kind: 'user' }, sessionId: input.session_id, cwd: input.cwd };
+  const { result, reachedCore, coreInput } = await mod.chain.dispatch('prompt.submit', e, async (final) => ({ isQueued: true, text: final.text }), mod.dispatchOptions());
+  if (plain(result) && typeof result.drop === 'string') return { decision: 'block', reason: result.drop };
+  const specific = { hookEventName: 'UserPromptSubmit' };
+  let any = false;
+  if (reachedCore && typeof coreInput?.text === 'string' && coreInput.text !== e.text) {
+    specific.replacementPrompt = coreInput.text;
+    any = true;
+  }
+  if (plain(result) && typeof result.context === 'string' && result.context.length > 0) {
+    specific.additionalContext = result.context;
+    any = true;
+  }
+  if (plain(result) && typeof result.sessionTitle === 'string') {
+    specific.sessionTitle = result.sessionTitle;
+    any = true;
+  }
+  return any ? { hookSpecificOutput: specific } : undefined;
+}
+
+/// Stop → `turn.complete`: a different `text` shows beneath the answer.
+async function turnComplete(mod, input) {
+  const e = { reason: input.stop_reason ?? 'end_turn', turnId: input.turn_id ?? null, text: input.last_assistant_message ?? '' };
+  const { result } = await mod.chain.dispatch('turn.complete', e, async (final) => ({ text: final.text }), mod.dispatchOptions());
+  if (plain(result) && typeof result.text === 'string' && result.text !== e.text && result.text.length > 0) {
+    return { systemMessage: result.text };
+  }
+  return undefined;
+}
+
+/// PreCompact → `session.compact`: `{ skip }` keeps the conversation.
+async function sessionCompact(mod, input) {
+  const e = { trigger: input.trigger ?? 'manual', instructions: input.custom_instructions ?? '', messages: [] };
+  const { result } = await mod.chain.dispatch('session.compact', e, async () => ({ messages: [] }), mod.dispatchOptions());
+  if (plain(result) && typeof result.skip === 'string') return { decision: 'block', reason: result.skip };
+  return undefined;
+}