@visual-z/xeno 0.8.3 → 0.9.0

package/src/core/events.ts

@@ -1,670 +0,0 @@
-/**
- * Append-only event log types.
- *
- * Two hard rules, both load-bearing:
- *
- * 1. APPEND REFERENCES, NEVER COPIES (decision D8). A `cut` event stores the id of
- *    the handoff it produced and a ref to its predecessor segment -- never the
- *    history it replaces. Codex CLI re-embeds the full `replacement_history` into
- *    its rollout JSONL on every compaction, which is O(n^2) on disk and has been
- *    reported to reach 42 GB (openai/codex#41806). The rule exists to make that
- *    shape unrepresentable.
- *
- * 2. HARNESS-DERIVED VS MODEL-ANNOTATED. Harness events are produced from things
- *    that cannot be wrong: the user typed this, the tool exited with this code.
- *    Model-annotated events are optional, may be wrong, and always have a
- *    deterministic fallback. Nothing load-bearing depends on the model's honesty --
- *    in particular, verification comes from exit codes, never from the model
- *    saying the tests passed.
- */
-
-import type { ExecutionOutcome } from "./outcome.ts";
-import type { ImageRef } from "./images.ts";
-import type { JsonValue, ToolDiagnostic } from "./tool-contract.ts";
-import type { AcceptanceContract } from "./acceptance.ts";
-import type { CheckpointEvent, WorkspaceObservationEvent } from "./checkpoints.ts";
-import type { ObservationReceipt } from "./read-observation.ts";
-import type { CommandArtifactReceipt } from "./command-artifacts.ts";
-import type { RuntimeTargetReceipt } from "./runtime-target.ts";
-
-export type EventId = string;
-export type Sha256 = string;
-export type IsoTime = string;
-
-/** Inclusive 1-indexed line range, matching how editors and tools report them. */
-export type LineRange = readonly [start: number, end: number];
-
-/**
- * A pointer to one node of the session tree.
- *
- * A single parent pointer is what makes the log a tree rather than a list --
- * the linear case is the degenerate tree where every node has exactly one
- * child. `node` is the ALLOCATION number, not a position in the tree:
- * structure lives only in parent pointers, the way a commit hash is an
- * identity and the parent link is the shape.
- */
-export type NodeRef = {
-  node: number;
-  log_ref: string;
-  sha256: Sha256;
-  /**
-   * Where in the parent this node branched off. Omitted means the parent's
-   * current end.
-   *
-   * An event id rather than a turn index. An index is only stable while
-   * nothing upstream can be inserted, edited or compacted, and while that
-   * holds inside a node today it is a property of the storage rather than of
-   * the pointer. The id already exists, is already unique, and gives one more
-   * thing for free: a pointer at an event that is not there can be detected,
-   * where an out-of-range index can only be range-checked.
-   */
-  at_event?: EventId;
-};
-
-// ---------------------------------------------------------------------------
-// Effects: what a tool call actually did, as classified by the tool registry.
-// ---------------------------------------------------------------------------
-
-/**
- * `gate` is attached by the harness from configured gate patterns, not guessed
- * from the command text. A command with no configured gate is still recorded --
- * it just counts as weaker evidence than a named gate.
- */
-export type Effect =
-  | { kind: "read"; path: string; sha256: Sha256; ranges?: readonly LineRange[] }
-  | { kind: "edit"; path: string; sha256_before: Sha256 | null; sha256_after: Sha256 }
-  | { kind: "command"; cmd: string; exit: number; gate?: string; workspace_sha256?: Sha256; workspace_observed?: boolean; workspace_scope?: "source-v1"; artifacts?: CommandArtifactReceipt };
-
-// ---------------------------------------------------------------------------
-// Harness-derived events
-// ---------------------------------------------------------------------------
-
-export interface UserEvent {
-  t: "user";
-  id: EventId;
-  at: IsoTime;
-  text: string;
-  /** Q23: in-flight steering belongs to this original user event; legacy events open a request. */
-  request?: EventId;
-  images?: readonly ImageRef[];
-}
-
-/** User-authorized shell execution is distinct from a model tool invocation (Pi !/!!). */
-export interface UserBashEvent {
-  t: "user_bash";
-  id: EventId;
-  at: IsoTime;
-  command: string;
-  content: string;
-  exit: number;
-  excludeFromContext: boolean;
-  outcome: ExecutionOutcome;
-  content_ref: ArtifactRef;
-}
-
-/** A terminal execution fact; human history must not turn a truncated answer into success. */
-export interface OutcomeEvent {
-  t: "outcome";
-  id: EventId;
-  at: IsoTime;
-  reason: string;
-  outcome: ExecutionOutcome;
-  /** Why a failed request failed; absent on success and in logs written before it existed. */
-  failure?: FailureCause;
-}
-
-/**
- * Credential-free facts about a failure (PLAYBOOK: provider error text never
- * reaches the log). `label` is a phrase from retry.ts's fixed vocabulary or an
- * error class name -- both chosen by code, never copied from a response body.
- */
-export interface FailureCause {
-  /** provider: the model request failed after its retries; harness: xeno itself threw. */
-  source: "provider" | "harness";
-  label: string;
-  status?: number;
-  /** Retries the adapter actually made before giving up. */
-  retries?: number;
-}
-
-/** A factual harness notice, appended once rather than rewriting the prompt (N.1). */
-export interface GuidanceEvent {
-  t: "guidance";
-  id: EventId;
-  at: IsoTime;
-  reason: "continuation" | "repetition" | "budget" | "boundary" | "stall" | "output_recovery" | "completion_review" | "churn" | "deadline" | "runtime_acceptance" | "goal" | "secret";
-  text: string;
-  sources: readonly EventId[];
-}
-
-/**
- * The user cancelled the turn that `user_id` opened.
- *
- * A later record, not a flag on that user event: the cancel happened after
- * the prompt was written, and rewriting a committed event would violate
- * append-only (D8). Only harness-observable facts are stored -- which prompt
- * and when -- never the partial assistant text, which was never delivered.
- * A cancelled generation is not a conversation that happened (same rule as
- * AGENT_PLAYBOOK "凭证与错误文本": a failed request is not a conversation).
- */
-export interface InterruptEvent {
-  t: "interrupt";
-  id: EventId;
-  at: IsoTime;
-  /** The user event whose turn was cancelled. */
-  user_id: EventId;
-}
-
-/**
- * Only the shapes the projection needs to replay a turn.
- *
- * A thinking block carries the provider's opaque fields alongside its text.
- * They must be replayed byte-for-byte: the API rejects blocks whose content
- * was modified, and a block whose text is empty still has to go back verbatim.
- * Keeping only the text would drop the signature and fail the next request --
- * so the raw block is kept under `raw` and replayed untouched, while `text` is
- * what a UI renders.
- */
-export type AssistantBlock =
-  | { type: "text"; text: string; wire?: unknown }
-  | { type: "thinking"; text: string; raw: unknown }
-  /**
-   * `wire` is the provider's own per-call data beyond id, name and arguments
-   * (Gemini's thought signature), replayed verbatim like a thinking block's raw.
-   */
-  | { type: "tool_use"; call_id: string; name: string; input: unknown; wire?: unknown };
-
-export interface AssistantEvent {
-  t: "assistant";
-  id: EventId;
-  at: IsoTime;
-  blocks: readonly AssistantBlock[];
-  /** N.12: provider-observed termination, never a claim of task completion. Legacy logs omit it. */
-  stop_reason?: string | null;
-  /** D8: opaque digest of the wire profile that produced signed blocks; no credentials. */
-  replay_key?: string;
-}
-
-export interface ToolResultEvent {
-  t: "tool_result";
-  id: EventId;
-  at: IsoTime;
-  call_id: string;
-  /** Trusted host execution has no provider tool_use and is excluded from provider replay. */
-  origin?: "extension";
-  /** Pi A: nested observations remain evidence without creating provider-visible tool pairs. */
-  parent_call_id?: string;
-  invocation_ref?: { node: number; event: EventId };
-  ok: boolean;
-  /** What the model sees. Large payloads belong on disk, referenced by effect. */
-  content: string;
-  images?: readonly ImageRef[];
-  /** Digest of the complete observation, even when it fits inline in the log. */
-  content_sha256?: Sha256;
-  /** O.3: semantic observation digest excludes presentation metadata. */
-  observation_sha256?: Sha256;
-  /** R2: exact preview coverage and immutable source identity; old logs omit this receipt. */
-  observation?: ObservationReceipt;
-  content_ref?: ArtifactRef;
-  effect?: Effect;
-  /** O.1: actual termination, independent of effect/verification; legacy logs omit it. */
-  outcome?: ExecutionOutcome;
-  /** O.3: machine-readable observations and recovery hints, not additional proof. */
-  data?: JsonValue;
-  /** Pi A: large structured results stay recoverable without bloating each JSONL event. */
-  data_ref?: ArtifactRef;
-  diagnostic?: ToolDiagnostic;
-  /** Post-operation observer failures cannot erase the operation's factual result. */
-  warnings?: readonly ToolDiagnostic[];
-  /**
-   * S.6 item 3: scoped instructions first discovered by this read-only call,
-   * shown after its content. Keys identify the accepted versions on resume.
-   */
-  instructions?: { keys: readonly string[]; text: string };
-}
-
-export type ArtifactRef = { sha256: Sha256; path: string; bytes: number };
-
-/** Pi A: an invocation is durable before its admitted action may start. */
-export interface ToolInvocationEvent {
-  t: "tool_invocation"; id: EventId; at: IsoTime;
-  call_id: string; name: string; parent_call_id?: string;
-  origin?: "extension";
-  parent_ref?: { node: number; event: EventId };
-  /** Original request and the exact declarative contract are independently recoverable. */
-  input_ref: ArtifactRef;
-  schema_ref: ArtifactRef | null;
-  /** Bounded actual arguments; absent for a direct unchanged request or an oversized refusal. */
-  input?: JsonValue;
-}
-
-/** Terminates the segment it appears in. Carries refs only -- see rule 1 above. */
-export interface CutEvent {
-  t: "cut";
-  id: EventId;
-  at: IsoTime;
-  handoff_ref: string;
-  predecessor: NodeRef | null;
-  reason: CutReason;
-  /** Durable transition intent; recovery opens this exact successor. */
-  next_node?: number;
-  next_model?: string;
-  /** Paired with next_model so crash recovery preserves the selected provider. */
-  next_provider?: string;
-  /** The successor request effort is durable even if the adapter has not been installed. */
-  next_thinking?: string;
-  /** D6: resource reload activates this frozen context only in the successor. */
-  next_context_ref?: Sha256;
-  /** V2 carried-state budget, fixed in the log for identical replay. */
-  handoff_tokens?: number;
-  /** O.10: absent preserves the original D20 carried projection. */
-  /** R9: present when the source-priority working set was carried across this cut. */
-  /** 3: user turns are carried before other pages, with image references and one copy of each next action. */
-  working_set_version?: 2 | 3;
-  /** R10: declared builtin advice capabilities at this cut, not an authorization grant. Absent replays old text. */
-  guidance_tools?: readonly string[];
-  /** N.8: first retained event on the effective ancestry; no copied transcript. */
-  retained_from?: EventId;
-}
-
-export type CutReason = "hard_limit" | "trigger" | "model_checkpoint";
-
-// ---------------------------------------------------------------------------
-// Model-annotated events (optional; every consumer has a fallback)
-// ---------------------------------------------------------------------------
-
-/**
- * How a completion claim points at its proof. Resolved against the log by
- * deriveHandoff(); a claim whose evidence does not resolve to a zero exit is
- * surfaced as unverified rather than accepted or silently dropped.
- */
-export type EvidenceQuery =
-  | { gate: string }
-  | { command: string };
-
-export interface ClaimEvent {
-  t: "claim";
-  id: EventId;
-  at: IsoTime;
-  what: string;
-  work_id?: string;
-  evidence: EvidenceQuery;
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-export interface DecisionEvent {
-  t: "decision";
-  id: EventId;
-  at: IsoTime;
-  chose: string;
-  because: string;
-  rejected?: readonly string[];
-  work_id?: string;
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-export interface PitfallEvent {
-  t: "pitfall";
-  id: EventId;
-  at: IsoTime;
-  tried: string;
-  failed_because: string;
-  work_id?: string;
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-export interface BlockedEvent {
-  t: "blocked";
-  id: EventId;
-  at: IsoTime;
-  what: string;
-  work_id?: string;
-  reason: string;
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-export interface QuestionEvent {
-  t: "question";
-  id: EventId;
-  at: IsoTime;
-  text: string;
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-/**
- * Which halves of a rewind moved.
- *
- *   both     the default. The conversation and the workspace go back
- *            together, so they still agree afterwards.
- *   files    the workspace goes back, the conversation does not. The model's
- *            context describes edits that are no longer on disk.
- *   context  the conversation goes back, the workspace does not. Files exist
- *            that the model has no memory of writing.
- */
-export type RewindMode = "both" | "files" | "context";
-
-/**
- * The workspace and the conversation were moved relative to each other.
- *
- * Recorded because the workspace is a projection of the log: a restore is a
- * change no tool claimed, so without this event the next turn-boundary scan
- * reports the whole thing as undeclared damage and the handoff inherits it.
- *
- * WHETHER IT REPLAYS DEPENDS ON `mode`, and the rule is the same one the
- * whole log follows: tell the model exactly when, and only when, its picture
- * would otherwise be wrong.
- *
- *   "both" does NOT replay. The context and the disk agree afterwards, and
- *   saying "you just rewound" would carry the undone work back in another
- *   form -- the exact thing being undone.
- *
- *   "files" and "context" DO replay, naming paths. They leave the two
- *   disagreeing, and a model planning against the wrong picture is the
- *   documented failure: with a context-only restore it "starts from bad code
- *   with no memory of how it got there", which is worse than either state.
- */
-export interface RewindEvent {
-  t: "rewind";
-  id: EventId;
-  at: IsoTime;
-  mode: RewindMode;
-  /** P.3: context navigation keeps the file history at this separate cursor. */
-  files_from?: NodeRef;
-  /** Where things were moved back to. */
-  from: NodeRef;
-  /** The prompt that opened the exchange moved back to, for a human reader. */
-  prompt: string;
-  restored: readonly string[];
-  removed: readonly string[];
-  /** Target files whose content is no longer in the blob store. */
-  unrecoverable: readonly string[];
-  /**
-   * Paths where the workspace and this conversation no longer agree, with
-   * which side is ahead. Computed from the plan, never described vaguely:
-   * "some files may differ" is not something a model can act on.
-   */
-  divergence: readonly string[];
-}
-
-// --- branch lifecycle ------------------------------------------------------
-
-/**
- * The parent opened a branch. Carries a reference, never the branch itself.
- */
-export interface SpawnEvent {
-  t: "spawn";
-  id: EventId;
-  at: IsoTime;
-  branch: NodeRef;
-  /** What the branch is for, in one line. */
-  purpose: string;
-  /** O.14: execution mode is durable; it never proves a live handle exists. */
-  background?: true;
-  /** The isolated checkout belongs to this branch, including after restart. */
-  workspace?: { path: string; branch: string };
-  /** O.4: a task input envelope references the original request, never copies history. */
-  input?: {
-    source_event: string;
-    tools: readonly string[];
-    max_turns: number;
-    workspace: { kind: "shared_readonly" } | { kind: "git_tree"; head: string; tree: string };
-  };
-}
-
-/**
- * A branch finished and handed its state back.
- *
- * `handoff_ref` is a path, and `summary` is a line the branch wrote -- the
- * handoff's contents are never inlined here (D8). The parent reads the file
- * when it needs the detail.
- */
-export interface JoinedEvent {
-  t: "joined";
-  id: EventId;
-  at: IsoTime;
-  branch: NodeRef;
-  handoff_ref: string;
-  summary: string;
-  /** O.9: artifact contains a deterministic evidence index, never raw history. */
-  receipt_ref?: Sha256;
-  /** A branch can cut before joining; its last node need not be its root. */
-  tip?: NodeRef;
-  model?: string;
-  /** Absence in a legacy join means unknown, never inferred success. */
-  outcome?: ExecutionOutcome;
-}
-
-/** The parent took this branch as the mainline. */
-export interface AdoptEvent {
-  t: "adopt";
-  id: EventId;
-  at: IsoTime;
-  branch: NodeRef;
-  /** Commit intent after all parent tool results; recovery reuses this node. */
-  next_node?: number;
-  applied?: true;
-}
-
-/** The parent rejected this branch. Resolution, not silence (D16). */
-export interface DiscardEvent {
-  t: "discard";
-  id: EventId;
-  at: IsoTime;
-  branch: NodeRef;
-  reason: string;
-}
-
-/**
- * Where an event was carried from, when an adopt moved it into a new node.
- *
- * Adopting a branch would otherwise lose the parent's post-fork annotations --
- * including the decision that chose the branch, which is the least disposable
- * record there is. Carrying them is free in context terms because model
- * annotations never replay as messages; only the derivation sees them.
- */
-export interface CarriedFrom {
-  node: number;
-  event: EventId;
-}
-
-/**
- * The one genuinely non-derivable field. "What was I doing" can be reconstructed
- * from the log; "what should happen next" cannot. When absent, the handoff says
- * so via continuation_valid rather than inventing one.
- */
-export interface NextActionEvent {
-  t: "next_action";
-  id: EventId;
-  at: IsoTime;
-  what: string;
-  work_id?: string;
-  next_action: string;
-  depends_on?: readonly string[];
-  /** Set when an adopt moved this event from another node. */
-  carried_from?: CarriedFrom;
-}
-
-/** O.2: lifecycle changes append facts; an old title is not a task identity. */
-export interface WorkStatusEvent {
-  t: "work_status";
-  id: EventId;
-  at: IsoTime;
-  work_id: string;
-  what: string;
-  operation: "unblock" | "reopen" | "cancel";
-  next_action?: string;
-  reason?: string;
-  carried_from?: CarriedFrom;
-}
-
-export interface WorkDependenciesEvent {
-  t: "work_dependencies"; id: EventId; at: IsoTime; work_id: string; what: string;
-  depends_on: readonly string[]; carried_from?: CarriedFrom;
-}
-export interface WorkOwnerEvent {
-  t: "work_owner"; id: EventId; at: IsoTime; work_id: string; what: string;
-  operation: "claim" | "release"; owner: string; carried_from?: CarriedFrom;
-}
-
-/** O.6: a model associates an original observation with work; the runtime resolves its source. */
-export interface EvidenceLinkEvent {
-  t: "evidence_link"; id: EventId; at: IsoTime;
-  work: string; what: string; source: EventId;
-  resource?: string; version?: string; supersedes?: EventId;
-  /** Last version observed by the harness when this association was recorded. */
-  observed_version?: string | null;
-  carried_from?: CarriedFrom;
-}
-
-/** Extension state is append-only data; only explicit messages enter either projection (D1). */
-export interface ExtensionEvent {
-  t: "extension"; id: string; at: string; customType: string;
-  content: string; display: boolean; inContext: boolean;
-  data?: import("./tool-contract.ts").JsonValue;
-}
-
-export interface AcceptanceContractEvent {
-  t: "acceptance_contract"; id: EventId; at: IsoTime; request: EventId;
-  contract: AcceptanceContract;
-}
-/**
- * S.2 / S.5: an explicit goal. `set` records exactly what the user accepted
- * from a model draft -- the draft itself stays in the assistant event it came
- * from -- and `clear` ends it. Only the user sets or clears one by command;
- * the harness clears it when the request ledger is verified.
- */
-/**
- * The discriminating rung of the evidence ladder: one accepted check re-run in
- * a disposable clone with this request's changes undone. Only what happened is
- * recorded -- the exit code there, or why nothing ran (the revert could not be
- * made exact, the check did not finish) -- with the role the criterion was
- * declared with. What that means is derived by `counterVerdict` (S.7).
- */
-export type CounterCheckEvent = { t: "counter_check"; id: EventId; at: IsoTime; request: EventId; criterion: string; command: string; guard?: true } &
-  ({ exit: number } | { reason: string });
-
-/**
- * The independent rung: one blind check run after the goal ended, in a clone of
- * the final workspace. `exposed` reports whether the log shows the model ever
- * touched the blind checks; an exposed pass does not count as independent.
- */
-export type BlindCheckEvent = { t: "blind_check"; id: EventId; at: IsoTime; request: EventId; check: string; exposed: boolean; exposure?: string } &
-  ({ exit: number } | { reason: string });
-
-export type GoalEvent =
-  | { t: "goal"; id: EventId; at: IsoTime; action: "set"; objective: string; contract: AcceptanceContract;
-      draft: EventId; accepted: readonly string[]; rejected: readonly string[] }
-  | { t: "goal"; id: EventId; at: IsoTime; action: "clear"; reason: "met" | "user" };
-export interface AcceptanceDecisionEvent {
-  t: "acceptance_decision"; id: EventId; at: IsoTime; request: EventId;
-  contract_id: string; criterion: string; actor: "user";
-  target_binding?: string; target_observation?: EventId;
-}
-export interface TargetObservationEvent {
-  t: "target_observation"; id: EventId; at: IsoTime; observation: RuntimeTargetReceipt;
-}
-
-export interface SkillLoadedEvent {
-  t: "skill_loaded"; id: EventId; at: IsoTime; name: string; path: string;
-  sha256: Sha256; artifact: Sha256; mode: "inline" | "fork" | "read"; origin: "user" | "model";
-}
-
-/** O.14: owner cleanup is an actual process observation, not a model claim. */
-export interface ProcessExitEvent {
-  t: "process_exit"; id: EventId; at: IsoTime; session: number;
-  command: string; exit: number; output: ArtifactRef; reason: "disposed";
-  receipt?: import("./process-receipt.ts").ProcessReceipt;
-}
-
-/**
- * Who let one call through the permission gate (feat-approval-events). A
- * harness fact recorded between the call's invocation and its result, before
- * the call starts; it never enters the model's context. `decision` is the
- * person's prompt choice when `source` is `user`, otherwise the rule's own
- * `allow` / `deny`. `rule` is the matched rule's text -- for `user`, the rule
- * that asked. `no_prompt`: a rule asked and nobody could be asked.
- */
-export interface ApprovalEvent {
-  t: "approval"; id: EventId; at: IsoTime;
-  call_id: string; tool: string;
-  decision: "once" | "command" | "tool" | "deny" | "allow";
-  source: "user" | "session_rule" | "config" | "auto" | "no_prompt";
-  command?: string;
-  rule?: string;
-}
-
-export type LogEvent =
-  | ToolInvocationEvent
-  | ApprovalEvent
-  | ProcessExitEvent
-  | SkillLoadedEvent
-  | AcceptanceContractEvent
-  | GoalEvent
-  | CounterCheckEvent
-  | BlindCheckEvent
-  | AcceptanceDecisionEvent
-  | TargetObservationEvent
-  | ExtensionEvent
-  | UserEvent
-  | UserBashEvent
-  | OutcomeEvent
-  | GuidanceEvent
-  | InterruptEvent
-  | AssistantEvent
-  | ToolResultEvent
-  | EvidenceLinkEvent
-  | CutEvent
-  | CheckpointEvent
-  | WorkspaceObservationEvent
-  | RewindEvent
-  | SpawnEvent
-  | JoinedEvent
-  | AdoptEvent
-  | DiscardEvent
-  | ClaimEvent
-  | DecisionEvent
-  | PitfallEvent
-  | BlockedEvent
-  | QuestionEvent
-  | NextActionEvent
-  | WorkStatusEvent
-  | WorkDependenciesEvent
-  | WorkOwnerEvent;
-// Work coordination is intent, never a substitute for command proof.
-
-export const HARNESS_EVENTS = [
-  "checkpoint", "workspace_observation",
-  "target_observation",
-  "process_exit",
-  "approval",
-  "skill_loaded",
-  "acceptance_contract", "acceptance_decision", "goal", "counter_check", "blind_check",
-  "user", "user_bash", "outcome", "guidance", "interrupt", "assistant", "tool_result", "cut", "rewind", "extension",
-] as const;
-export const MODEL_EVENTS = [
-  "work_dependencies", "work_owner",
-  "claim", "decision", "pitfall", "blocked", "question", "next_action", "work_status", "evidence_link",
-  "spawn", "joined", "adopt", "discard",
-] as const;
-
-/**
- * Events an adopt carries into the node it opens.
- *
- * Only annotations: harness events are either already in the branch's
- * ancestry or are parent actions the branch should not inherit.
- */
-export const CARRYABLE_EVENTS = [
-  "work_dependencies", "work_owner",
-  "claim", "decision", "pitfall", "blocked", "question", "next_action", "work_status", "evidence_link",
-] as const;
-
-export type CarryableEvent = Extract<LogEvent, { t: (typeof CARRYABLE_EVENTS)[number] }>;
-
-export function isHarnessEvent(e: LogEvent): boolean {
-  return (HARNESS_EVENTS as readonly string[]).includes(e.t);
-}