harnery 0.33.0 → 0.34.0

package/src/core/guard/live-source-v3.ts

@@ -0,0 +1,204 @@
+import {
+  type EventV3,
+  type ReadLedgerV3Result,
+  readEventV3ControlState,
+  readLedgerV3,
+  reduceSafetyProjectionV3,
+} from "../events/v3/index.ts";
+import {
+  isRunQualityCorpusCategoryV3,
+  normalizeRunQualityEventV3,
+  normalizeRunQualityPairingV3,
+} from "./evidence-v3.ts";
+import type {
+  RunQualityCorpusCategoryV3,
+  RunQualityEvidenceEvent,
+  RunQualityRoleWait,
+} from "./types.ts";
+
+export type RunQualityLiveEpochStateV3 = "candidate" | "active";
+
+export interface RunQualityLiveGenerationV3 {
+  instance_id: string;
+  session_id: string;
+  generation_id: string;
+  adapter: string;
+  events: RunQualityEvidenceEvent[];
+  corpus_categories: RunQualityCorpusCategoryV3[];
+  role_wait: RunQualityRoleWait;
+  evidence: {
+    first_event_id?: string;
+    last_event_id?: string;
+    window_started_at?: string;
+    window_ended_at?: string;
+    segment: string;
+    truncated: boolean;
+  };
+  sufficient_history: boolean;
+}
+
+export interface RunQualityLiveSourceV3 {
+  contract_major: 3;
+  genesis_id: string;
+  epoch_state: RunQualityLiveEpochStateV3;
+  generations: RunQualityLiveGenerationV3[];
+}
+
+export class RunQualityLiveSourceV3Error extends Error {
+  constructor(
+    public readonly code: "control_not_ready" | "ledger_integrity_failure",
+    public readonly details: string[],
+  ) {
+    super(`run_quality_live_v3:${code}:${details.join(",")}`);
+    this.name = "RunQualityLiveSourceV3Error";
+  }
+}
+
+/**
+ * Read live advisory inputs from the validated V3 ledger. Candidate epochs are
+ * observable here for rehearsal, but corpus eligibility remains active-only.
+ */
+export function readRunQualityLiveSourceV3(
+  coordRoot: string,
+  now: Date = new Date(),
+): RunQualityLiveSourceV3 {
+  const control = readEventV3ControlState(coordRoot);
+  if (control.state !== "candidate" && control.state !== "active") {
+    throw new RunQualityLiveSourceV3Error("control_not_ready", [
+      control.state,
+      "reason" in control ? control.reason : "unknown",
+    ]);
+  }
+  return projectRunQualityLiveSourceV3(
+    readLedgerV3(coordRoot),
+    control.genesis.event.payload.genesis_id,
+    control.state,
+    now,
+  );
+}
+
+/** Pure projection used by the live coordinator and replay-equivalence tests. */
+export function projectRunQualityLiveSourceV3(
+  read: ReadLedgerV3Result,
+  genesisId: string,
+  epochState: RunQualityLiveEpochStateV3,
+  now: Date,
+): RunQualityLiveSourceV3 {
+  if (!read.complete) {
+    throw new RunQualityLiveSourceV3Error("ledger_integrity_failure", [
+      ...new Set(read.diagnostics.map(({ code }) => code)),
+    ]);
+  }
+  const safety = reduceSafetyProjectionV3(read);
+  const generations: RunQualityLiveGenerationV3[] = [];
+  for (const state of Object.values(safety.generations)) {
+    if (state.phase !== "live") continue;
+    const positioned = read.events.filter(
+      ({ event }) =>
+        "generation_id" in event.scope && event.scope.generation_id === state.generation_id,
+    );
+    const started = positioned.find(({ event }) => event.event_type === "session.started")?.event;
+    if (started?.event_type !== "session.started") continue;
+    const prior = new Map<string, EventV3>();
+    const evidenceEvents: RunQualityEvidenceEvent[] = [];
+    const corpusCategories = new Set<RunQualityCorpusCategoryV3>();
+    for (const { event } of positioned) {
+      for (const normalized of normalizeRunQualityEventV3(event, prior)) {
+        if (isRunQualityCorpusCategoryV3(normalized.kind)) corpusCategories.add(normalized.kind);
+        else evidenceEvents.push(normalized);
+      }
+      prior.set(event.event_id, event);
+    }
+    for (const marker of normalizeRunQualityPairingV3(positioned.map(({ event }) => event))) {
+      if (isRunQualityCorpusCategoryV3(marker.kind)) corpusCategories.add(marker.kind);
+    }
+    const first = evidenceEvents[0];
+    const last = evidenceEvents.at(-1);
+    const lastPosition = positioned.at(-1)?.position;
+    const diagnostic = safety.diagnostics.some(
+      (entry) => entry.generation_id === state.generation_id && entry.authority_blocking,
+    );
+    generations.push({
+      instance_id: state.instance_id,
+      session_id: state.session_id,
+      generation_id: state.generation_id,
+      adapter: observedAdapter(started),
+      events: evidenceEvents,
+      corpus_categories: [...corpusCategories].sort(),
+      role_wait: roleWait(state.waits, state.started_at, now),
+      evidence: {
+        first_event_id: first?.event_id,
+        last_event_id: last?.event_id,
+        window_started_at: first?.ts,
+        window_ended_at: last?.ts,
+        segment: `v3:${lastPosition?.segment_ordinal ?? 0}`,
+        truncated: diagnostic,
+      },
+      sufficient_history: !diagnostic,
+    });
+  }
+  generations.sort((left, right) => left.generation_id.localeCompare(right.generation_id));
+  return { contract_major: 3, genesis_id: genesisId, epoch_state: epochState, generations };
+}
+
+function observedAdapter(event: Extract<EventV3, { event_type: "session.started" }>): string {
+  const adapter = event.payload.runtime_attestation.adapter;
+  return adapter.state === "observed" ? adapter.value.id : "unknown";
+}
+
+function roleWait(
+  waits: Record<
+    string,
+    {
+      wait_id: string;
+      kind: string;
+      started_at: string;
+      wake_at?: string;
+    }
+  >,
+  generationStartedAt: string,
+  now: Date,
+): RunQualityRoleWait {
+  const current = Object.values(waits).sort((left, right) =>
+    left.started_at.localeCompare(right.started_at),
+  );
+  if (current.length === 0) {
+    return {
+      role: "agent",
+      wait_kind: "none",
+      source: "event_v3",
+      observed_at: generationStartedAt,
+      fresh: false,
+    };
+  }
+  const latest = current.at(-1)!;
+  const scheduledExpired =
+    latest.kind === "scheduled" &&
+    latest.wake_at !== undefined &&
+    Date.parse(latest.wake_at) <= now.getTime();
+  return {
+    role: "agent",
+    wait_kind: current.length > 1 ? "unknown" : waitKind(latest.kind),
+    source: "event_v3",
+    observed_at: latest.started_at,
+    fresh: !scheduledExpired,
+    record_id: latest.wait_id,
+    wake_at: latest.wake_at,
+  };
+}
+
+function waitKind(kind: string): RunQualityRoleWait["wait_kind"] {
+  switch (kind) {
+    case "operator_input":
+      return "needs_input";
+    case "decision":
+      return "decision";
+    case "permission":
+    case "approval":
+      return "approval";
+    case "scheduled":
+      return "scheduled";
+    default:
+      return "unknown";
+  }
+}

package/src/core/guard/storage.ts

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import type { RunQualitySnapshot } from "./types.ts";
+
+export interface GuardCursor {
+  schema_version: 1;
+  segment: string;
+  last_event_id?: string;
+  next_eligible_at: string;
+  config_digest: string;
+  updated_at: string;
+}
+
+export interface EvaluationLock {
+  pid: number;
+  acquired_at: string;
+  nonce: string;
+}
+
+export function guardDir(coordRoot: string): string {
+  return join(coordRoot, ".harnery", "guard");
+}
+
+export function snapshotPath(coordRoot: string, instanceId: string): string {
+  return join(guardDir(coordRoot), `${instanceId}.json`);
+}
+
+export function readRunQualitySnapshot(
+  coordRoot: string,
+  instanceId: string,
+): RunQualitySnapshot | null {
+  return readBoundedJson<RunQualitySnapshot>(snapshotPath(coordRoot, instanceId), 1024 * 1024);
+}
+
+export function readFreshRunQualitySnapshot(
+  coordRoot: string,
+  instanceId: string,
+  now: Date = new Date(),
+): RunQualitySnapshot | null {
+  const snapshot = readRunQualitySnapshot(coordRoot, instanceId);
+  return snapshot && Date.parse(snapshot.expires_at) > now.getTime() ? snapshot : null;
+}
+
+export function readGuardCursor(coordRoot: string): GuardCursor | null {
+  return readBoundedJson<GuardCursor>(join(guardDir(coordRoot), "cursor.json"), 64 * 1024);
+}
+
+export function writeGuardCursor(coordRoot: string, cursor: GuardCursor, nonce: string): void {
+  writeAtomicJson(join(guardDir(coordRoot), "cursor.json"), cursor, nonce, () =>
+    evaluationLockOwned(coordRoot, nonce),
+  );
+}
+
+export function writeRunQualitySnapshot(
+  coordRoot: string,
+  snapshot: RunQualitySnapshot,
+  nonce: string,
+): void {
+  writeAtomicJson(snapshotPath(coordRoot, snapshot.instance_id), snapshot, nonce, () =>
+    evaluationLockOwned(coordRoot, nonce),
+  );
+}
+
+export function acquireEvaluationLock(
+  coordRoot: string,
+  now: Date,
+  staleSeconds: number,
+): EvaluationLock | null {
+  const path = join(guardDir(coordRoot), "evaluate.lock");
+  mkdirSync(dirname(path), { recursive: true });
+  const lock: EvaluationLock = {
+    pid: process.pid,
+    acquired_at: now.toISOString(),
+    nonce: randomUUID(),
+  };
+  if (createExclusive(path, lock)) return lock;
+  const existing = readBoundedJson<EvaluationLock>(path, 16 * 1024);
+  const age = existing
+    ? now.getTime() - Date.parse(existing.acquired_at)
+    : Number.POSITIVE_INFINITY;
+  if (existing && processAlive(existing.pid) && age <= staleSeconds * 1000) return null;
+  try {
+    unlinkSync(path);
+  } catch {
+    return null;
+  }
+  return createExclusive(path, lock) ? lock : null;
+}
+
+export function evaluationLockOwned(coordRoot: string, nonce: string): boolean {
+  return (
+    readBoundedJson<EvaluationLock>(join(guardDir(coordRoot), "evaluate.lock"), 16 * 1024)
+      ?.nonce === nonce
+  );
+}
+
+export function releaseEvaluationLock(coordRoot: string, nonce: string): void {
+  const path = join(guardDir(coordRoot), "evaluate.lock");
+  if (!evaluationLockOwned(coordRoot, nonce)) return;
+  try {
+    unlinkSync(path);
+  } catch {
+    // A replacement owner won the race; nonce ownership already prevents removal.
+  }
+}
+
+export function cleanupOrphanSnapshots(coordRoot: string, liveIds: Set<string>): void {
+  const dir = guardDir(coordRoot);
+  if (!existsSync(dir)) return;
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json") || name === "cursor.json" || name === "config-invalid.json")
+      continue;
+    const instanceId = name.slice(0, -5);
+    if (liveIds.has(instanceId)) continue;
+    try {
+      unlinkSync(join(dir, name));
+    } catch {
+      // Cleanup is advisory and retries on the next evaluation.
+    }
+  }
+}
+
+export function writeAtomicJson(
+  path: string,
+  value: unknown,
+  nonce: string,
+  beforeRename?: () => boolean,
+): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.tmp-${process.pid}-${nonce}`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+    if (beforeRename && !beforeRename()) throw new Error("run_quality_lock_stolen");
+    renameSync(temporary, path);
+  } finally {
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+function createExclusive(path: string, value: EvaluationLock): boolean {
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "wx", 0o600);
+    writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    return false;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+function processAlive(pid: number): boolean {
+  if (!Number.isSafeInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+function readBoundedJson<T>(path: string, maxBytes: number): T | null {
+  if (!existsSync(path)) return null;
+  try {
+    const size = statSync(path).size;
+    if (size <= 0 || size > maxBytes) return null;
+    return JSON.parse(readFileSync(path, "utf8")) as T;
+  } catch {
+    return null;
+  }
+}

package/src/core/guard/types.ts

@@ -0,0 +1,152 @@
+export const RUN_QUALITY_SCHEMA_VERSION = 1 as const;
+
+export type RunQualityMode = "off" | "shadow" | "report";
+export type RunQualityStatus = "unknown" | "healthy" | "attention" | "critical";
+export type RunQualitySignalState = "inactive" | "active" | "unknown" | "suppressed";
+export type RunQualityWaitKind =
+  | "none"
+  | "needs_input"
+  | "decision"
+  | "approval"
+  | "scheduled"
+  | "unknown";
+
+export interface RunQualityThresholds {
+  repeated_tool_calls: number;
+  consecutive_failures: number;
+  context_growth_per_minute: number;
+  compaction_grace_seconds: number;
+  no_progress_evaluations: number;
+}
+
+export interface RunQualityConfig {
+  mode: RunQualityMode;
+  evaluation_interval_seconds: number;
+  snapshot_ttl_seconds: number;
+  max_tail_bytes: number;
+  evaluation_timeout_seconds: number;
+  lock_stale_seconds: number;
+  supervised_roots_per_sweep: number;
+  thresholds: RunQualityThresholds;
+}
+
+export interface RunQualityConfigResult {
+  config: RunQualityConfig | null;
+  digest: string;
+  valid: boolean;
+  requested_mode: RunQualityMode;
+  reason_codes: string[];
+}
+
+export interface RunQualityRoleWait {
+  role: string;
+  wait_kind: RunQualityWaitKind;
+  source: string;
+  observed_at: string;
+  fresh: boolean;
+  record_id?: string;
+  wake_at?: string;
+}
+
+export type RunQualityEvidenceKind =
+  | "tool_call"
+  | "tool_success"
+  | "tool_failure"
+  | "tool_pairing_incomplete"
+  | "command_pairing_incomplete"
+  | "recovered_terminal"
+  | "context_sample"
+  | "progress"
+  | "compaction_started"
+  | "compaction_completed";
+
+export type RunQualityCorpusCategoryV3 = Extract<
+  RunQualityEvidenceKind,
+  "tool_pairing_incomplete" | "command_pairing_incomplete" | "recovered_terminal"
+>;
+
+export interface RunQualityEvidenceEvent {
+  event_id: string;
+  ts: string;
+  kind: RunQualityEvidenceKind;
+  input_hash?: string;
+  target_hash?: string;
+  used_tokens?: number;
+  confidence?: "exact" | "reported" | "estimated";
+  telemetry_source?: string;
+}
+
+export interface RunQualitySignal {
+  id:
+    | "repeated_tool_calls"
+    | "consecutive_failures"
+    | "context_growth"
+    | "target_stagnation"
+    | "no_progress"
+    | "compaction_grace";
+  state: RunQualitySignalState;
+  severity: "none" | "attention" | "critical";
+  count: number;
+  reason_code: string;
+}
+
+export interface RunQualityEvaluatorState {
+  repeated_hash?: string;
+  repeated_count: number;
+  exact_hash_seen: boolean;
+  missing_hash_seen: boolean;
+  target_hash?: string;
+  target_streak: number;
+  target_hash_seen: boolean;
+  failure_streak: number;
+  work_since_progress: number;
+  last_context?: { used_tokens: number; ts: string };
+  context_growth_per_minute?: number;
+  no_progress_epochs: number;
+  no_progress_deadline_epochs: number;
+  compaction_grace_until?: string;
+}
+
+export interface RunQualitySnapshot {
+  schema_version: typeof RUN_QUALITY_SCHEMA_VERSION;
+  instance_id: string;
+  session_id: string;
+  session_generation: string;
+  adapter: string;
+  config_digest: string;
+  mode: Exclude<RunQualityMode, "off">;
+  status: RunQualityStatus;
+  previous_status: RunQualityStatus;
+  evaluated_at: string;
+  next_eligible_at: string;
+  expires_at: string;
+  evidence: {
+    first_event_id?: string;
+    last_event_id?: string;
+    window_started_at?: string;
+    window_ended_at?: string;
+    segment: string;
+    truncated: boolean;
+  };
+  signals: RunQualitySignal[];
+  role_wait: RunQualityRoleWait;
+  state: RunQualityEvaluatorState;
+  epoch: "evidence" | "deadline" | "read";
+  reason: "evidence" | "deadline" | "config_changed" | "insufficient_evidence";
+}
+
+export interface EvaluateRunQualityInput {
+  instance_id: string;
+  session_id: string;
+  session_generation: string;
+  adapter: string;
+  now: string;
+  config: RunQualityConfig;
+  config_digest: string;
+  events: RunQualityEvidenceEvent[];
+  previous?: RunQualitySnapshot;
+  role_wait: RunQualityRoleWait;
+  evidence: RunQualitySnapshot["evidence"];
+  sufficient_history: boolean;
+  live: boolean;
+}

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

@@ -1,5 +1,5 @@
 import { coordEnv } from "../../../lib/env.ts";
-import type { Adapter } from "../events/schema.ts";
+import type { Adapter } from "../../adapter.ts";
 
 /**
  * Resolve the adapter firing the hook. The dispatcher binary is always
@@ -24,3 +24,30 @@ function validate(v: string | undefined): Adapter | null {
   if (v === "claude-code" || v === "cursor" || v === "codex") return v;
   return null;
 }
+
+/**
+ * On a host wired for multiple adapters, Cursor also executes the Claude Code
+ * project hooks, piping them the same payload as its own hooks. Recording that
+ * stray `--adapter claude-code` dispatch mints a twin generation for the same
+ * instance (plus a stream of missing_session_start diagnostics), so the hook
+ * CLI skips it entirely.
+ *
+ * Detection reads the payload, not the environment: every hook payload Cursor
+ * emits carries a top-level `cursor_version` string (its dispatch envelope),
+ * and no Claude Code payload does. Environment sniffing cannot make this call
+ * in either direction — Cursor's own hook processes do not carry CURSOR_AGENT
+ * (only its agent tool shells do), and a genuine Claude Code session nested
+ * under a Cursor agent shell inherits Cursor-flavored variables it must not
+ * be skipped for. The check is the top-level key only: a Claude Code payload
+ * whose tool_input merely mentions the string must not match.
+ */
+export function shouldSkipHookAdapter(adapter: Adapter | null, rawPayload: string): boolean {
+  if (adapter !== "claude-code") return false;
+  if (!rawPayload || rawPayload.trim().length === 0) return false;
+  try {
+    const json = JSON.parse(rawPayload) as Record<string, unknown>;
+    return typeof json.cursor_version === "string" && json.cursor_version.length > 0;
+  } catch {
+    return false;
+  }
+}

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

@@ -9,9 +9,9 @@
  * Codex `.codex/hooks.json`).
  */
 
-export type { Adapter as AdapterId } from "../events/schema.ts";
+export type { Adapter as AdapterId } from "../../adapter.ts";
 
-import type { Adapter as AdapterId } from "../events/schema.ts";
+import type { Adapter as AdapterId } from "../../adapter.ts";
 
 export interface HookEvent {
   /** Key under the adapter settings file's `hooks` map (e.g. `SessionStart`, `preToolUse`). */
@@ -55,6 +55,7 @@ export interface AdapterSpec {
 export const CLAUDE_CODE_EVENTS: HookEvent[] = [
   { settingsKey: "SessionStart", subcommand: "session-start" },
   { settingsKey: "UserPromptSubmit", subcommand: "user-prompt-submit" },
+  { settingsKey: "PermissionRequest", subcommand: "permission-request" },
   { settingsKey: "Stop", subcommand: "stop" },
   { settingsKey: "StopFailure", subcommand: "stop-failure" },
   { settingsKey: "SessionEnd", subcommand: "session-end" },
@@ -64,22 +65,28 @@ export const CLAUDE_CODE_EVENTS: HookEvent[] = [
   { settingsKey: "PostToolUse", subcommand: "post-tool-use" },
   { settingsKey: "PostToolUseFailure", subcommand: "post-tool-use-failure" },
   { settingsKey: "PreCompact", subcommand: "pre-compact" },
+  { settingsKey: "PostCompact", subcommand: "post-compact" },
 ];
 
 /**
  * Cursor: `.cursor/hooks.json`. camelCase event keys; flat `{ command }` entries;
- * no `StopFailure` event, but a distinct `beforeShellExecution` (shell-mutation warn).
+ * no `StopFailure` event. Generic tool hooks remain useful in the IDE, while
+ * shell-specific hooks are also installed because remote/CLI modes do not
+ * dispatch generic tool hooks consistently. V3 deduplicates overlapping shell
+ * deliveries by a private command fingerprint.
  */
 export const CURSOR_EVENTS: HookEvent[] = [
   { settingsKey: "sessionStart", subcommand: "session-start" },
   { settingsKey: "sessionEnd", subcommand: "session-end" },
   { settingsKey: "preToolUse", subcommand: "pre-tool-use" },
-  { settingsKey: "beforeShellExecution", subcommand: "before-shell-execution" },
   { settingsKey: "postToolUse", subcommand: "post-tool-use" },
   { settingsKey: "postToolUseFailure", subcommand: "post-tool-use-failure" },
+  { settingsKey: "beforeShellExecution", subcommand: "before-shell-execution" },
+  { settingsKey: "afterShellExecution", subcommand: "after-shell-execution" },
   { settingsKey: "subagentStart", subcommand: "sub-agent-start" },
   { settingsKey: "subagentStop", subcommand: "sub-agent-stop" },
   { settingsKey: "beforeSubmitPrompt", subcommand: "user-prompt-submit" },
+  { settingsKey: "preCompact", subcommand: "pre-compact" },
   { settingsKey: "stop", subcommand: "stop" },
 ];
 
@@ -95,16 +102,16 @@ export const CODEX_EVENTS: HookEvent[] = [
   { settingsKey: "PreCompact", subcommand: "pre-compact" },
   { settingsKey: "PostCompact", subcommand: "post-compact" },
   { settingsKey: "Stop", subcommand: "stop" },
+  { settingsKey: "SessionEnd", subcommand: "session-end" },
 ];
 
 /** Entries written by harnery before Codex adopted a strict native hook schema. */
 export const LEGACY_CODEX_EVENTS: HookEvent[] = [
-  { settingsKey: "SessionEnd", subcommand: "session-end" },
   { settingsKey: "PostToolUseFailure", subcommand: "post-tool-use-failure" },
   { settingsKey: "StopFailure", subcommand: "stop-failure" },
 ];
 
-/** Every hook key accepted by Codex 0.144, including events harnery does not consume. */
+/** Every hook key accepted by Codex's current native hook schema. */
 export const CODEX_ALLOWED_EVENT_KEYS = [
   "SessionStart",
   "PreToolUse",
@@ -116,6 +123,7 @@ export const CODEX_ALLOWED_EVENT_KEYS = [
   "SubagentStart",
   "SubagentStop",
   "Stop",
+  "SessionEnd",
 ];
 
 /** Every supported adapter, fully wireable by `harn init`. */

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

@@ -18,11 +18,16 @@
  * fire-and-forget. Empty text → no-op (no JSON written).
  */
 
+import type { Adapter } from "../../adapter.ts";
 import { STOP_REMEDIATION_MARKER } from "../../agents/rules/stop-hook.ts";
 import { endOfTurnStatusCommand, resolveBinName } from "../../config.ts";
-import type { Adapter } from "../events/schema.ts";
 
-export type SystemEvent = "SessionStart" | "UserPromptSubmit" | "SubagentStart";
+export type SystemEvent =
+  | "SessionStart"
+  | "UserPromptSubmit"
+  | "SubagentStart"
+  | "PreToolUse"
+  | "PostToolUse";
 
 /** Emit a context-injection (peer table, wiring check, council pending, …). */
 export function emitContext(adapter: Adapter, event: SystemEvent, text: string): void {