harnery 0.40.0 → 0.42.0

package/src/core/hooks/adapter/behaviors/index.ts

@@ -0,0 +1,31 @@
+import type { EventAdapterIdV3 } from "../../../events/v3/adapter-id.ts";
+import { claudeCodeBehavior } from "./claude-code.ts";
+import { codexBehavior } from "./codex.ts";
+import { cursorBehavior } from "./cursor.ts";
+import { openclawBehavior } from "./openclaw.ts";
+import { opencodeBehavior } from "./opencode.ts";
+import type { AdapterBehavior } from "./types.ts";
+
+export type {
+  AdapterBehavior,
+  CrossShellInput,
+  EffortAttestationSource,
+  PromptContextNudges,
+} from "./types.ts";
+
+/**
+ * One behavior per adapter id. The `Record` type makes a new adapter id a
+ * compile error here until its module exists.
+ */
+export const ADAPTER_BEHAVIORS: Record<EventAdapterIdV3, AdapterBehavior> = {
+  "claude-code": claudeCodeBehavior,
+  cursor: cursorBehavior,
+  codex: codexBehavior,
+  opencode: opencodeBehavior,
+  openclaw: openclawBehavior,
+};
+
+/** The single lookup the hook CLI and the V3 producer use instead of branching. */
+export function adapterBehavior(adapter: EventAdapterIdV3): AdapterBehavior {
+  return ADAPTER_BEHAVIORS[adapter];
+}

package/src/core/hooks/adapter/behaviors/openclaw.ts

@@ -0,0 +1,36 @@
+import type { AdapterBehavior } from "./types.ts";
+
+/**
+ * OpenClaw: event-only. Its plugin bundles the V3 producer and never runs the
+ * hook CLI, so every hook-process effect is off and telemetry is native only.
+ */
+export const openclawBehavior: AdapterBehavior = {
+  id: "openclaw",
+  sessionStartPlatformLabel: undefined,
+  soundEffects: false,
+  journalMaintenance: false,
+  sessionTelemetrySync: false,
+  promptPresenceDetection: false,
+  promptContextNudges: {
+    taskNudge: false,
+    hostPromptReminder: false,
+    statusFooterNudge: false,
+    turnRitualNudge: undefined,
+  },
+  completedResponseEvent: undefined,
+  sessionIdentityOnStartOnly: false,
+  nativeTurnIdOptional: false,
+  tracksExecutionMode: false,
+  shellOperationDedup: false,
+  promptMayPrecedeSessionStart: false,
+  promptContinuesOpenTurn: false,
+  turnRecovery: true,
+  nativeTelemetryOnly: true,
+  runtimeContextTranscriptOptional: false,
+  runtimeContextRetry: false,
+  effortAttestation: "none",
+  transcriptTuningRefresh: false,
+  modelProvider: "openclaw",
+  runtimeContextAvailable: () => false,
+  bridgeFor: () => undefined,
+};

package/src/core/hooks/adapter/behaviors/opencode.ts

@@ -0,0 +1,36 @@
+import type { AdapterBehavior } from "./types.ts";
+
+/**
+ * OpenCode: events arrive through the Harnery plugin bridging to agent-hook.
+ * No host-side effects, no exit-code enforcement, no effort dial.
+ */
+export const opencodeBehavior: AdapterBehavior = {
+  id: "opencode",
+  sessionStartPlatformLabel: "OpenCode",
+  soundEffects: false,
+  journalMaintenance: false,
+  sessionTelemetrySync: false,
+  promptPresenceDetection: false,
+  promptContextNudges: {
+    taskNudge: false,
+    hostPromptReminder: false,
+    statusFooterNudge: false,
+    turnRitualNudge: undefined,
+  },
+  completedResponseEvent: undefined,
+  sessionIdentityOnStartOnly: false,
+  nativeTurnIdOptional: false,
+  tracksExecutionMode: false,
+  shellOperationDedup: false,
+  promptMayPrecedeSessionStart: false,
+  promptContinuesOpenTurn: false,
+  turnRecovery: false,
+  nativeTelemetryOnly: false,
+  runtimeContextTranscriptOptional: false,
+  runtimeContextRetry: false,
+  effortAttestation: "none",
+  transcriptTuningRefresh: false,
+  modelProvider: "opencode",
+  runtimeContextAvailable: () => true,
+  bridgeFor: () => undefined,
+};

package/src/core/hooks/adapter/behaviors/types.ts

@@ -0,0 +1,110 @@
+import type { Adapter } from "../../../adapter.ts";
+import type { EventAdapterIdV3 } from "../../../events/v3/adapter-id.ts";
+import type { CodexWslFileLinkTelemetry } from "../../codex-wsl-bridge.ts";
+import type { ParsedPayload } from "../parse.ts";
+import type { RuntimeTelemetryOptions } from "../runtime-telemetry.ts";
+
+/** Flags passed to the prompt-context renderer on every user prompt. */
+export interface PromptContextNudges {
+  taskNudge: boolean;
+  hostPromptReminder: boolean;
+  statusFooterNudge: boolean;
+  turnRitualNudge: Adapter | undefined;
+}
+
+/** Inputs for the cross-shell safety inspection on a tool request. */
+export interface CrossShellInput {
+  cwd: unknown;
+  toolName: string | undefined;
+  toolInput: unknown;
+}
+
+/** Where a producer learns the effective effort/speed dial from. */
+export type EffortAttestationSource = "payload" | "rollout-probe" | "none";
+
+/**
+ * Everything the hook CLI and the V3 producer decide per adapter. Each
+ * adapter owns one module under this directory; `adapterBehavior(id)` is the
+ * only lookup, so the middle of the pipeline never branches on an adapter id.
+ *
+ * Every field is a decision the shared code used to make with an equality
+ * check. Booleans are effect gates, strings are labels, and the optional
+ * methods are adapter-native helpers that only exist for that adapter.
+ */
+export interface AdapterBehavior {
+  readonly id: EventAdapterIdV3;
+
+  // ── Session-boundary effects ────────────────────────────────────────────
+  /** Label shown in the session-start context; `undefined` means the host default. */
+  readonly sessionStartPlatformLabel: string | undefined;
+  /** The hook process plays notification sounds (kill-switch independent). */
+  readonly soundEffects: boolean;
+  /** Journal janitor at start, recovery cue in the start context, archive at end. */
+  readonly journalMaintenance: boolean;
+  /** Session telemetry sync extension at session end and on stop. */
+  readonly sessionTelemetrySync: boolean;
+  /** Presence (mobile vs office) is inferred from the submitted prompt text. */
+  readonly promptPresenceDetection: boolean;
+  readonly promptContextNudges: PromptContextNudges;
+
+  // ── Turn correlation in the V3 producer ─────────────────────────────────
+  /** Hook event that carries the completed assistant reply, when stop lacks it. */
+  readonly completedResponseEvent: string | undefined;
+  /** Native session identity arrives only on the start signal; later hooks join by instance. */
+  readonly sessionIdentityOnStartOnly: boolean;
+  /** A terminal or telemetry probe may proceed without a native turn id. */
+  readonly nativeTurnIdOptional: boolean;
+  /** The producer tracks a native execution mode (local/cloud) in its state. */
+  readonly tracksExecutionMode: boolean;
+  /** Shell hooks may deliver the same command twice; dedupe by a command fingerprint. */
+  readonly shellOperationDedup: boolean;
+  /** The native prompt signal can arrive before session start and is a trusted boundary. */
+  readonly promptMayPrecedeSessionStart: boolean;
+  /** A prompt signal inside an open turn continues that turn instead of starting a new one. */
+  readonly promptContinuesOpenTurn: boolean;
+  /** Missed hook signals may be recovered into derived turns and spans. */
+  readonly turnRecovery: boolean;
+
+  // ── Runtime telemetry ───────────────────────────────────────────────────
+  /** Turn telemetry comes only from the native payload; no runtime transcript read. */
+  readonly nativeTelemetryOnly: boolean;
+  /** Runtime context telemetry does not require a transcript path. */
+  readonly runtimeContextTranscriptOptional: boolean;
+  /** Late runtime-context samples are retried after stop (rollout flush lag). */
+  readonly runtimeContextRetry: boolean;
+  readonly effortAttestation: EffortAttestationSource;
+  /** After a payload effort change, refresh speed and model from the transcript row. */
+  readonly transcriptTuningRefresh: boolean;
+  /** Provider label attached to attested model identity. */
+  readonly modelProvider: string;
+  /** Whether runtime context can be read at all under the given execution mode. */
+  runtimeContextAvailable(executionMode: string | undefined): boolean;
+
+  // ── Deployment bridge ───────────────────────────────────────────────────
+  /** Bridge descriptor stamped on events when the payload cwd shows a bridged deployment. */
+  bridgeFor(cwd: unknown): "codex-wsl" | undefined;
+
+  // ── Adapter-native helpers (present only where the adapter needs them) ──
+  /** Locate (or verify) the session transcript when hook payloads omit `transcript_path`. */
+  discoverTranscript?(
+    nativeSessionId: string,
+    candidate?: string,
+    options?: RuntimeTelemetryOptions,
+  ): string | undefined;
+  /** Privacy-safe environment provenance recorded when a session onboards mid-flight. */
+  midFlightDiagnosticContext?(payload: ParsedPayload): Record<string, string | boolean>;
+  /** Completed-reply text supplied inline on tool hooks (no transcript needed). */
+  inlineAssistantText?(payload: ParsedPayload | null): string | undefined;
+  /** Extra turn.completed telemetry about file links under a bridged deployment. */
+  fileLinkTelemetry?(
+    coordRoot: string,
+    cwd: unknown,
+    lastAssistantMessage: string,
+  ): CodexWslFileLinkTelemetry | null;
+  /** Context block teaching the agent how file links resolve under a bridge. */
+  fileLinkContext?(coordRoot: string, cwd: unknown): string;
+  /** Warning appended to the session-start context when the bridge is misconfigured. */
+  bridgeWarning?(coordRoot: string, cwd: unknown): string | undefined;
+  /** Deny reason for a tool call whose shell shape is unsafe under the bridge. */
+  unsafeCrossShellReason?(input: CrossShellInput): string | null;
+}

package/src/core/hooks/adapter/detect.ts

@@ -1,5 +1,5 @@
 import { coordEnv } from "../../../lib/env.ts";
-import type { Adapter } from "../../adapter.ts";
+import { type Adapter, normalizeAdapter } from "../../adapter.ts";
 
 /**
  * Resolve the adapter firing the hook. The dispatcher binary is always
@@ -21,8 +21,7 @@ export function detectAdapter(argv: readonly string[]): Adapter | null {
 }
 
 function validate(v: string | undefined): Adapter | null {
-  if (v === "claude-code" || v === "cursor" || v === "codex") return v;
-  return null;
+  return normalizeAdapter(v);
 }
 
 /**

package/src/core/hooks/adapter/events.ts

@@ -27,13 +27,33 @@ export interface HookEvent {
  */
 export type HookEntryShape = "claude" | "cursor";
 
+/**
+ * How `harn init` installs this adapter's lifecycle capture:
+ * - `settings-hooks` (default): merge `agent-hook <subcommand>` command hooks
+ *   into a settings file's `hooks` map (Claude Code, Codex, Cursor).
+ * - `opencode-plugin`: OpenCode V2 has no command-hook file; interception is an
+ *   in-process plugin. `init` copies the Harnery plugin into the auto-discovered
+ *   `.opencode/plugins/harnery/` directory (entry `index.ts` + `harnery.json`),
+ *   and wiring inspection checks that owned file rather than a `hooks` map. The
+ *   plugin bridges each lifecycle hook to `agent-hook <subcommand> --adapter
+ *   opencode`, so `events` still names the subcommands it delivers.
+ */
+export type AdapterInstallMode = "settings-hooks" | "opencode-plugin";
+
 export interface AdapterSpec {
-  /** Settings file to wire, relative to the project root. */
+  /**
+   * Settings file to wire, relative to the project root. For the
+   * `opencode-plugin` install mode this is the installed plugin entry file.
+   */
   settingsFile: string;
   /** Events this adapter fires, mapped to agent-hook subcommands. */
   events: HookEvent[];
   /** Per-entry encoding under the root `hooks` object. */
   entryShape: HookEntryShape;
+  /** Install mechanism; absent means the default settings-file command hooks. */
+  installMode?: AdapterInstallMode;
+  /** For `opencode-plugin`: the plugin id OpenCode reports for the installed plugin. */
+  pluginId?: string;
   /** When set, ensure this top-level `version` key in the file (Cursor requires `1`). */
   rootVersion?: number;
   /** Adapter-owned entries from older specs that `init` should remove during migration. */
@@ -49,6 +69,20 @@ export interface AdapterSpec {
    * wandered (the session shell `cd`ing into a subdirectory or off-repo).
    */
   projectDirEnv?: string;
+  /**
+   * Per-handler `timeout` (seconds) written on every Harnery hook entry. Without
+   * one, an adapter's own default applies (Codex: 600 seconds), so a stalled
+   * hook can hold a tool call for ten minutes. `bySubcommand` overrides
+   * `default` for one event.
+   */
+  hookTimeouts?: { default: number; bySubcommand?: Record<string, number> };
+  /**
+   * The adapter runs a handler's `commandWindows` instead of `command` on
+   * Windows. A project that opts in (`hooks.codexWindowsBridge`) gets one that
+   * hands the hook to a resident WSL bridge (ADR 0197); otherwise init leaves
+   * the field off.
+   */
+  windowsBridgeHooks?: boolean;
 }
 
 /** Claude Code: `.claude/settings.json`. */
@@ -112,6 +146,29 @@ export const LEGACY_CODEX_EVENTS: HookEvent[] = [
   { settingsKey: "StopFailure", subcommand: "stop-failure" },
 ];
 
+/**
+ * OpenCode V2: delivered by the Harnery OpenCode plugin, which registers
+ * in-process hooks and bridges each to `agent-hook <subcommand> --adapter
+ * opencode`. There is no settings-file `hooks` map; `settingsKey` here is the
+ * originating OpenCode plugin hook, kept for documentation. `post-compact` is
+ * omitted because OpenCode post-compaction recovery is not yet certified. The
+ * plugin source (`opencode-plugin/src/index.ts`) carries the same map.
+ */
+export const OPENCODE_EVENTS: HookEvent[] = [
+  { settingsKey: "event:session.created", subcommand: "session-start" },
+  { settingsKey: "session.hook:prompt", subcommand: "user-prompt-submit" },
+  { settingsKey: "tool.hook:execute.before", subcommand: "pre-tool-use" },
+  { settingsKey: "tool.hook:execute.after", subcommand: "post-tool-use" },
+  { settingsKey: "tool.hook:execute.after:error", subcommand: "post-tool-use-failure" },
+  { settingsKey: "permission.hook:evaluate", subcommand: "permission-request" },
+  { settingsKey: "event:session.created:child", subcommand: "sub-agent-start" },
+  { settingsKey: "event:session.execution.*:child", subcommand: "sub-agent-stop" },
+  { settingsKey: "event:session.execution.succeeded", subcommand: "stop" },
+  { settingsKey: "event:session.execution.failed|interrupted", subcommand: "stop-failure" },
+  { settingsKey: "event:session.deleted", subcommand: "session-end" },
+  { settingsKey: "session.hook:compaction", subcommand: "pre-compact" },
+];
+
 /** Every hook key accepted by Codex's current native hook schema. */
 export const CODEX_ALLOWED_EVENT_KEYS = [
   "SessionStart",
@@ -148,5 +205,19 @@ export const ADAPTER_SPECS: Record<AdapterId, AdapterSpec> = {
     legacyEvents: LEGACY_CODEX_EVENTS,
     allowedTopLevelKeys: ["description", "hooks"],
     allowedEventKeys: CODEX_ALLOWED_EVENT_KEYS,
+    // A Codex hook that times out fails open: the run is marked failed and
+    // the tool proceeds. Codex clamps SessionEnd to 3 seconds and defaults it
+    // to 1, which is too short for a cold hook start.
+    hookTimeouts: { default: 20, bySubcommand: { "session-end": 3 } },
+    windowsBridgeHooks: true,
+  },
+  opencode: {
+    settingsFile: ".opencode/plugins/harnery/index.ts",
+    events: OPENCODE_EVENTS,
+    // entryShape is unused for the plugin install mode but required by the type;
+    // the plugin, not a hooks-map entry, carries the wiring.
+    entryShape: "claude",
+    installMode: "opencode-plugin",
+    pluginId: "harnery",
   },
 };

package/src/core/hooks/adapter/opencode-plugin.ts

@@ -0,0 +1,177 @@
+/**
+ * Install-side owner of the OpenCode plugin files: what `harn init --adapter
+ * opencode` writes, what `--check`/`doctor` compare against, and what `deinit`
+ * removes. The plugin itself lives in `opencode-plugin/src/index.ts` and is
+ * copied verbatim under a hash-stamped ownership header, the same fully-owned
+ * file contract as the shipped skills (`lib/instructions/splice.ts`).
+ *
+ * Layout under the project root (`ADAPTER_SPECS.opencode.settingsFile` names
+ * the entry file):
+ *
+ *   .opencode/plugins/harnery/index.ts    # the plugin, header + verbatim source
+ *   .opencode/plugins/harnery/harnery.json # { schema, agentHook } written by init
+ *
+ * OpenCode auto-discovers every directory under `.opencode/plugins/`, so no
+ * `opencode.json` edit is needed and a configured-plugin entry is never
+ * written (OpenCode also refuses a configured local *file*; only directories
+ * load that way).
+ */
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { shortHash } from "../../../lib/instructions/splice.ts";
+import { ADAPTER_SPECS } from "./events.ts";
+
+export const OPENCODE_PLUGIN_ENTRY = ADAPTER_SPECS.opencode.settingsFile;
+export const OPENCODE_PLUGIN_DIR = dirname(OPENCODE_PLUGIN_ENTRY);
+export const OPENCODE_PLUGIN_CONFIG = `${OPENCODE_PLUGIN_DIR}/harnery.json`;
+export const OPENCODE_PLUGIN_CONFIG_SCHEMA = "harnery-opencode-plugin/v1";
+
+const HEADER_RE = /^\/\/ harnery:generated opencode-plugin v=([0-9a-f]{8});[^\n]*\n/;
+
+/** Package-relative path of the shipped plugin source (also listed in `files`). */
+const PLUGIN_SOURCE = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "..",
+  "..",
+  "opencode-plugin",
+  "src",
+  "index.ts",
+);
+
+/** The plugin source as shipped, trimmed so header + body hashing is stable. */
+export function openCodePluginSource(): string {
+  return readFileSync(PLUGIN_SOURCE, "utf8").trim();
+}
+
+/** Render the installed entry file: ownership header, then the verbatim source. */
+export function renderOpenCodePluginEntry(
+  binName: string,
+  source = openCodePluginSource(),
+): string {
+  const body = source.trim();
+  const header =
+    `// harnery:generated opencode-plugin v=${shortHash(body)}; machine-owned; ` +
+    `regenerated by \`${binName} init --adapter opencode\`, removed by \`${binName} deinit --adapter opencode\`. ` +
+    "Edit harnery's opencode-plugin/src/index.ts, not this file.";
+  return `${header}\n${body}\n`;
+}
+
+/** Render the sibling config the plugin reads to find the `agent-hook` launcher. */
+export function renderOpenCodePluginConfig(agentHook: string): string {
+  return `${JSON.stringify({ schema: OPENCODE_PLUGIN_CONFIG_SCHEMA, agentHook }, null, 2)}\n`;
+}
+
+/** True when the content carries harnery's plugin ownership header. */
+export function isOwnedOpenCodePlugin(content: string): boolean {
+  return HEADER_RE.test(content);
+}
+
+export type OpenCodePluginStatus = "missing" | "fresh" | "stale" | "foreign";
+
+export interface OpenCodePluginCheck {
+  status: OpenCodePluginStatus;
+  /** Human-readable drift reasons, one per problem; empty when fresh or missing. */
+  issues: string[];
+}
+
+/**
+ * Compare the installed plugin files with what init would write now. Pure
+ * except for reads; never writes. `foreign` means an entry file exists at the
+ * harnery path without harnery's header, which init refuses to overwrite.
+ */
+export function checkOpenCodePlugin(
+  projectRoot: string,
+  expected: { binName: string; agentHook: string; source?: string },
+): OpenCodePluginCheck {
+  const entryPath = resolve(projectRoot, OPENCODE_PLUGIN_ENTRY);
+  const configPath = resolve(projectRoot, OPENCODE_PLUGIN_CONFIG);
+  if (!existsSync(entryPath)) return { status: "missing", issues: [] };
+  const content = readFileSync(entryPath, "utf8");
+  const match = HEADER_RE.exec(content);
+  if (!match) {
+    return {
+      status: "foreign",
+      issues: [`${OPENCODE_PLUGIN_ENTRY}: exists without harnery's ownership header`],
+    };
+  }
+  const issues: string[] = [];
+  const body = content.slice(match[0].length).trim();
+  const fresh = (expected.source ?? openCodePluginSource()).trim();
+  if (match[1] !== shortHash(fresh) || body !== fresh) {
+    issues.push(`${OPENCODE_PLUGIN_ENTRY}: plugin source is stale (re-run init)`);
+  }
+  if (!existsSync(configPath)) {
+    issues.push(`${OPENCODE_PLUGIN_CONFIG}: missing`);
+  } else if (readFileSync(configPath, "utf8") !== renderOpenCodePluginConfig(expected.agentHook)) {
+    issues.push(`${OPENCODE_PLUGIN_CONFIG}: stale agent-hook launcher (re-run init)`);
+  }
+  return { status: issues.length === 0 ? "fresh" : "stale", issues };
+}
+
+export interface OpenCodePluginInstall {
+  actions: string[];
+  /** Set when init must stop: a foreign file sits at the harnery path. */
+  error?: string;
+}
+
+/** Write (or refresh) the plugin directory. Idempotent; a fresh install is a no-op. */
+export function installOpenCodePlugin(
+  projectRoot: string,
+  opts: { binName: string; agentHook: string; dryRun: boolean },
+): OpenCodePluginInstall {
+  const check = checkOpenCodePlugin(projectRoot, opts);
+  if (check.status === "foreign") {
+    return {
+      actions: [],
+      error:
+        `✗ ${OPENCODE_PLUGIN_ENTRY} exists but is not harnery's plugin; refusing to overwrite. ` +
+        "Move it aside and re-run.",
+    };
+  }
+  if (check.status === "fresh") {
+    return { actions: [`· opencode plugin already installed at ${OPENCODE_PLUGIN_DIR}/`] };
+  }
+  const verb = check.status === "missing" ? "install" : "refresh";
+  if (opts.dryRun) {
+    return {
+      actions: [
+        `+ would ${verb} the opencode plugin at ${OPENCODE_PLUGIN_DIR}/ (index.ts + harnery.json)`,
+        ...check.issues.map((issue) => `  · ${issue}`),
+      ],
+    };
+  }
+  const dir = resolve(projectRoot, OPENCODE_PLUGIN_DIR);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    resolve(projectRoot, OPENCODE_PLUGIN_ENTRY),
+    renderOpenCodePluginEntry(opts.binName),
+  );
+  writeFileSync(
+    resolve(projectRoot, OPENCODE_PLUGIN_CONFIG),
+    renderOpenCodePluginConfig(opts.agentHook),
+  );
+  return {
+    actions: [
+      `+ ${verb === "install" ? "installed" : "refreshed"} the opencode plugin at ${OPENCODE_PLUGIN_DIR}/ (index.ts + harnery.json)`,
+    ],
+  };
+}
+
+/** Remove the plugin directory when harnery owns it. Leaves a foreign file alone. */
+export function removeOpenCodePlugin(projectRoot: string, dryRun: boolean): string[] {
+  const dir = resolve(projectRoot, OPENCODE_PLUGIN_DIR);
+  const entryPath = resolve(projectRoot, OPENCODE_PLUGIN_ENTRY);
+  if (!existsSync(entryPath)) {
+    return [`· ${OPENCODE_PLUGIN_DIR}/ doesn't exist; no plugin to remove`];
+  }
+  if (!isOwnedOpenCodePlugin(readFileSync(entryPath, "utf8"))) {
+    return [`· ${OPENCODE_PLUGIN_ENTRY} is not harnery's plugin; left in place`];
+  }
+  if (dryRun) return [`+ would remove ${OPENCODE_PLUGIN_DIR}/ (harnery-owned plugin)`];
+  rmSync(dir, { recursive: true, force: true });
+  return [`+ removed ${OPENCODE_PLUGIN_DIR}/ (harnery-owned plugin)`];
+}

package/src/core/hooks/adapter/output.ts

@@ -14,6 +14,9 @@
  * - **Codex**: structurally identical to Claude Code for context and tool
  *   denials. Stop blocks are deliberately suppressed because their automatic
  *   continuation can replace a completed user-facing answer.
+ * - **OpenCode**: the Harnery OpenCode plugin reads the Claude Code envelope
+ *   (`hookSpecificOutput.additionalContext` / `permissionDecision`) and feeds
+ *   it back through OpenCode's own channels. Stop blocks are suppressed.
  *
  * Every helper writes to process.stdout + newline-terminates so callers can
  * fire-and-forget. Empty text is a no-op.
@@ -65,6 +68,10 @@ export function emitDeny(adapter: Adapter, reason: string): void {
  *   answer in clients that retain only the final continuation response. Return
  *   success without output as a defense in depth behind the observe-only
  *   verdict in `agents/rules/stop-hook.ts`.
+ * - **OpenCode** has no blocking Stop channel at all: the plugin observes
+ *   `session.execution.succeeded` after the turn has already completed, so a
+ *   block could only arrive as a new message. Return success without output;
+ *   the verdict is still recorded in the ledger.
  * - **Cursor** ignores stop-hook exit codes (non-zero = fail-open, the turn
  *   proceeds) and re-prompts ONLY via a `followup_message` field in stdout
  *   JSON, which it auto-submits as the next user message: the sanctioned
@@ -88,7 +95,7 @@ export function emitStopOutcome(
   options: StopOutputOptions,
   coordRoot?: string,
 ): 0 | 2 {
-  if (adapter === "codex") return 0;
+  if (adapter === "codex" || adapter === "opencode") return 0;
 
   const verdict = options.verdict;
   if (!verdict) return 0;

package/src/core/hooks/adapter/runtime-telemetry.ts

@@ -671,7 +671,9 @@ function claudeModelContextCapability(model: string): ClaudeModelContextCapabili
   const normalized = model.toLowerCase();
   const oneMillionTokenModels = new Set([
     "claude-fable-5",
+    "claude-opus-5-5",
     "claude-opus-5",
+    "claude-sonnet-5-5",
     "claude-sonnet-5",
     "claude-opus-4-8",
     "claude-opus-4-7",
@@ -679,7 +681,7 @@ function claudeModelContextCapability(model: string): ClaudeModelContextCapabili
     "claude-sonnet-4-6",
   ]);
   if (oneMillionTokenModels.has(normalized)) {
-    return { limit_tokens: 1_000_000, authority: "anthropic_model_capabilities_2026_08" };
+    return { limit_tokens: 1_000_000, authority: "anthropic_model_capabilities_2026_09" };
   }
   if (normalized === "claude-haiku-4-5" || normalized === "claude-haiku-4-5-20251001") {
     return { limit_tokens: 200_000, authority: "anthropic_model_capabilities_2026_08" };