@harness-kernel/core 0.1.0-beta.0

package/dist/chunk-4WWSQAWA.js

@@ -0,0 +1,3778 @@
+import {
+  HarnessModelProviderRegistry,
+  modelProviderId
+} from "./chunk-Q73WH5D7.js";
+import {
+  AgentDebugLog,
+  AgentErrorLog,
+  AgentInfoLog,
+  AgentWarnLog,
+  ConsoleLogSink,
+  HarnessLog,
+  normalizeHarnessLog,
+  randomId,
+  shouldWriteLog,
+  summarizeValue
+} from "./chunk-Q44U2CMM.js";
+import {
+  HarnessSandboxSession,
+  NoopSandbox
+} from "./chunk-AD3BCYWU.js";
+import {
+  NoopRunStorage
+} from "./chunk-AZVA22HW.js";
+import {
+  ContextReadyEvent,
+  ErrorEvent,
+  MessageDeltaEvent,
+  MessageEndEvent,
+  MessageStartEvent,
+  ModeChangedEvent,
+  ModelAfterEvent,
+  ModelBeforeEvent,
+  RunEndEvent,
+  RunStartEvent,
+  SnapshotCreatedEvent,
+  SnapshotDeletedEvent,
+  SnapshotRestoredEvent,
+  ToolApprovalRequestedEvent,
+  ToolApprovalResolvedEvent,
+  ToolEndEvent,
+  ToolStartEvent,
+  TranscriptCursorChangedEvent,
+  TurnEndEvent,
+  TurnStartEvent,
+  runtimeEventClasses
+} from "./chunk-4SYLFKIX.js";
+import {
+  normalizeSchema
+} from "./chunk-OBKS4AJR.js";
+import {
+  HarnessContextProvider,
+  HarnessEvent,
+  HarnessHook,
+  HarnessMode,
+  HarnessRole,
+  HarnessTool,
+  assistantRole,
+  systemRole,
+  toolRole,
+  userRole
+} from "./chunk-4A2P4QU5.js";
+
+// src/logging/tool-errors.ts
+function createToolErrorPayload(input) {
+  return {
+    ok: false,
+    error: {
+      code: input.code,
+      message: input.message,
+      toolName: input.toolName,
+      invalidFields: input.invalidFields,
+      metadata: input.metadata
+    }
+  };
+}
+
+// src/logging/runtime-logs.ts
+var SessionCreatedLog = class extends HarnessLog {
+  level = "info";
+  category = "session";
+  message() {
+    return "session.created";
+  }
+};
+var RunStartedLog = class extends HarnessLog {
+  level = "info";
+  category = "run";
+  message(fields) {
+    return `run.started mode=${fields.modeId} model=${fields.model}`;
+  }
+};
+var RunCompletedLog = class extends HarnessLog {
+  level = "info";
+  category = "run";
+  message(fields) {
+    return `run.completed durationMs=${fields.durationMs} messages=${fields.messageCount} events=${fields.eventCount}`;
+  }
+};
+var RunFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "run";
+  message() {
+    return "run.failed";
+  }
+};
+var TurnStartedLog = class extends HarnessLog {
+  level = "info";
+  category = "turn";
+  message(fields) {
+    return `turn.started ${fields.turnId}`;
+  }
+};
+var TurnCompletedLog = class extends HarnessLog {
+  level = "info";
+  category = "turn";
+  message() {
+    return "turn.completed";
+  }
+};
+var ContextBuildStartedLog = class extends HarnessLog {
+  level = "debug";
+  category = "context";
+  message(fields) {
+    return `context.started providers=${fields.providerCount}`;
+  }
+};
+var ContextBuildCompletedLog = class extends HarnessLog {
+  level = "info";
+  category = "context";
+  message(fields) {
+    return `context.ready providers=${fields.providerCount} contributions=${fields.contributionCount} durationMs=${fields.durationMs}`;
+  }
+};
+var ContextProviderFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "context";
+  message(fields) {
+    return `context.provider.failed ${fields.providerType}`;
+  }
+};
+var ModelCallStartedLog = class extends HarnessLog {
+  level = "info";
+  category = "model";
+  message(fields) {
+    return `model.started model=${fields.model} messages=${fields.messageCount}`;
+  }
+};
+var ModelCallCompletedLog = class extends HarnessLog {
+  level = "info";
+  category = "model";
+  message(fields) {
+    return `model.completed model=${fields.model} durationMs=${fields.durationMs}${fields.finishReason ? ` finish=${fields.finishReason}` : ""}`;
+  }
+};
+var ModelCallFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "model";
+  message(fields) {
+    return `model.failed model=${fields.model}`;
+  }
+};
+var ModelDeltaLog = class extends HarnessLog {
+  level = "info";
+  category = "model";
+  message(fields) {
+    return `model.delta length=${fields.length}`;
+  }
+};
+var ToolStartedLog = class extends HarnessLog {
+  level = "info";
+  category = "tool";
+  message(fields) {
+    return `tool.started ${fields.toolName}`;
+  }
+};
+var ToolArgsEmptyLog = class extends HarnessLog {
+  level = "warn";
+  category = "tool";
+  message(fields) {
+    return `tool.args.empty ${fields.toolName}`;
+  }
+};
+var ToolInvalidSchemaLog = class extends HarnessLog {
+  level = "error";
+  category = "tool";
+  message(fields) {
+    return `tool.args.invalid_schema ${fields.toolName}`;
+  }
+};
+var ToolCompletedLog = class extends HarnessLog {
+  level = "info";
+  category = "tool";
+  message(fields) {
+    return `tool.completed ${fields.toolName} durationMs=${fields.durationMs} isError=${fields.isError}`;
+  }
+};
+var ToolFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "tool";
+  message(fields) {
+    return `tool.failed ${fields.toolName}`;
+  }
+};
+var ToolApprovalRequestedLog = class extends HarnessLog {
+  level = "warn";
+  category = "approval";
+  message(fields) {
+    return `tool.approval.requested ${fields.toolName}`;
+  }
+};
+var ToolApprovalResolvedLog = class extends HarnessLog {
+  level = "info";
+  category = "approval";
+  levelFor(fields) {
+    return fields.approved ? "info" : "warn";
+  }
+  message(fields) {
+    return fields.approved ? `tool.approval.approved ${fields.toolName}` : `tool.approval.denied ${fields.toolName}`;
+  }
+};
+var SandboxOpenedLog = class extends HarnessLog {
+  level = "info";
+  category = "tool";
+  message(fields) {
+    return `sandbox.opened ${fields.sandboxId}`;
+  }
+};
+var SandboxExecStartedLog = class extends HarnessLog {
+  level = "debug";
+  category = "tool";
+  message(fields) {
+    return `sandbox.exec.started ${fields.sandboxId}`;
+  }
+};
+var SandboxExecCompletedLog = class extends HarnessLog {
+  level = "debug";
+  category = "tool";
+  message(fields) {
+    return `sandbox.exec.completed ${fields.sandboxId} exitCode=${fields.exitCode ?? "null"} durationMs=${fields.durationMs}`;
+  }
+};
+var SandboxExecFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "tool";
+  message(fields) {
+    return `sandbox.exec.failed ${fields.sandboxId}`;
+  }
+};
+var SandboxClosedLog = class extends HarnessLog {
+  level = "info";
+  category = "tool";
+  message(fields) {
+    return `sandbox.closed ${fields.sandboxId}`;
+  }
+};
+var RunStorageOpenedLog = class extends HarnessLog {
+  level = "debug";
+  category = "storage";
+  message(fields) {
+    return `storage.opened ${fields.storageId} run=${fields.runId}`;
+  }
+};
+var SnapshotCreatedLog = class extends HarnessLog {
+  level = "info";
+  category = "snapshot";
+  message() {
+    return "snapshot.created";
+  }
+};
+var SnapshotRestoredLog = class extends HarnessLog {
+  level = "info";
+  category = "snapshot";
+  message() {
+    return "snapshot.restored";
+  }
+};
+var SnapshotRestoreRejectedLog = class extends HarnessLog {
+  level = "warn";
+  category = "snapshot";
+  message() {
+    return "snapshot.restore_rejected";
+  }
+};
+var SnapshotDeletedLog = class extends HarnessLog {
+  level = "info";
+  category = "snapshot";
+  message() {
+    return "snapshot.deleted";
+  }
+};
+var TranscriptCursorChangedLog = class extends HarnessLog {
+  level = "debug";
+  category = "transcript";
+  message() {
+    return "transcript.cursor_changed";
+  }
+};
+var StorageWriteFailedLog = class extends HarnessLog {
+  level = "error";
+  category = "storage";
+  message(fields) {
+    return `storage.write_failed ${fields.operation}`;
+  }
+};
+
+// src/runtime/constructs.ts
+function constructClass(value) {
+  return typeof value === "function" ? value : value.constructor;
+}
+function stripConstructSuffix(name) {
+  return name.replace(/(ContextProvider|Provider|Tool|Mode|Hook|Role|Event)$/u, "");
+}
+function wordsFromName(name) {
+  const spaced = name.replace(/[_:-]+/gu, " ").replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2").trim();
+  return spaced ? spaced.split(/\s+/u) : [name];
+}
+function snakeFromType(type) {
+  return wordsFromName(stripConstructSuffix(type)).map((word) => word.toLowerCase()).join("_");
+}
+function labelFromType(type) {
+  return wordsFromName(stripConstructSuffix(type)).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getConstructType(constructOrClass) {
+  const cls = constructClass(constructOrClass);
+  return cls.type ?? cls.name ?? "AnonymousConstruct";
+}
+function getConstructLabel(constructOrClass) {
+  const instanceLabel = typeof constructOrClass === "object" && "label" in constructOrClass && typeof constructOrClass.label === "string" ? constructOrClass.label : void 0;
+  if (instanceLabel) return instanceLabel;
+  const cls = constructClass(constructOrClass);
+  return cls.label ?? labelFromType(getConstructType(constructOrClass));
+}
+function getToolName(toolOrClass) {
+  if (typeof toolOrClass === "object" && typeof toolOrClass.name === "string") return toolOrClass.name;
+  const cls = constructClass(toolOrClass);
+  return cls.name ?? snakeFromType(getConstructType(toolOrClass));
+}
+function getRoleName(role) {
+  return role.name ?? role.nativeRole ?? snakeFromType(getConstructType(role));
+}
+function modeSummary(mode) {
+  return {
+    type: getConstructType(mode),
+    label: getConstructLabel(mode)
+  };
+}
+function contextProviderSummary(provider, options) {
+  return {
+    type: getConstructType(provider),
+    label: getConstructLabel(provider),
+    options
+  };
+}
+function isConstructInstance(value, BaseClass) {
+  return value instanceof BaseClass;
+}
+function isModeInstance(value) {
+  return isConstructInstance(value, HarnessMode);
+}
+function isToolInstance(value) {
+  return isConstructInstance(value, HarnessTool);
+}
+function isContextProviderInstance(value) {
+  return isConstructInstance(value, HarnessContextProvider);
+}
+function isRoleInstance(value) {
+  return isConstructInstance(value, HarnessRole);
+}
+function isHookInstance(value) {
+  return isConstructInstance(value, HarnessHook);
+}
+function isClassLike(value) {
+  return typeof value === "function" && typeof value.prototype === "object";
+}
+function isModeClass(value) {
+  return isClassLike(value) && HarnessMode.prototype.isPrototypeOf(value.prototype);
+}
+function isToolClass(value) {
+  return isClassLike(value) && HarnessTool.prototype.isPrototypeOf(value.prototype);
+}
+function isRoleClass(value) {
+  return isClassLike(value) && HarnessRole.prototype.isPrototypeOf(value.prototype);
+}
+function isContextProviderClass(value) {
+  return isClassLike(value) && HarnessContextProvider.prototype.isPrototypeOf(value.prototype);
+}
+function modeMatchesSelector(mode, selector) {
+  if (typeof selector === "string") return getConstructType(mode) === selector;
+  if (isModeClass(selector)) return mode instanceof selector || getConstructType(mode) === getConstructType(selector);
+  return mode === selector || mode.constructor === selector.constructor || getConstructType(mode) === getConstructType(selector);
+}
+function toolMatchesSelector(tool, selector) {
+  if (typeof selector === "string") return getToolName(tool) === selector || getConstructType(tool) === selector;
+  if (isToolClass(selector)) return tool instanceof selector || getConstructType(tool) === getConstructType(selector);
+  return tool === selector || tool.constructor === selector.constructor || getConstructType(tool) === getConstructType(selector);
+}
+function roleMatchesSelector(role, selector) {
+  if (typeof selector === "string") {
+    return getRoleName(role) === selector || getConstructType(role) === selector || role.nativeRole === selector;
+  }
+  if (isRoleClass(selector)) return role instanceof selector || getConstructType(role) === getConstructType(selector);
+  return role === selector || role.constructor === selector.constructor || getConstructType(role) === getConstructType(selector);
+}
+function contextProviderMatchesSelector(provider, selector) {
+  if (typeof selector === "string") return getConstructType(provider) === selector;
+  if (isContextProviderClass(selector)) {
+    return provider instanceof selector || getConstructType(provider) === getConstructType(selector);
+  }
+  return provider === selector || provider.constructor === selector.constructor || getConstructType(provider) === getConstructType(selector);
+}
+function hookEventClass(hook) {
+  const eventClass = hook.eventClass;
+  if (eventClass) return eventClass;
+  const legacyEvents = hook.events;
+  if (legacyEvents !== void 0) {
+    throw new Error(
+      `Hook '${getConstructType(hook)}' uses the old events array. Extend HarnessHook.for(EventClass) instead.`
+    );
+  }
+  return void 0;
+}
+function eventType(eventClass) {
+  return getConstructType(eventClass);
+}
+function isContextProviderBinding(value) {
+  return typeof value === "object" && value !== null && "provider" in value && (isContextProviderInstance(value.provider) || isContextProviderClass(value.provider));
+}
+function isContextProviderReference(value) {
+  return isContextProviderInstance(value) || isContextProviderClass(value) || isContextProviderBinding(value);
+}
+function assertNoAuthorId(construct, kind) {
+  if (Object.prototype.hasOwnProperty.call(construct, "id")) {
+    throw new Error(`${kind} '${getConstructType(construct)}' declares an author id. Use the class type instead.`);
+  }
+}
+
+// src/runtime/context-registry.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneJSON(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var ContextRegistry = class {
+  snapshots = [];
+  currentSnapshot;
+  entries = [];
+  get current() {
+    return this.currentSnapshot;
+  }
+  get allEntries() {
+    return this.entries;
+  }
+  restore(input) {
+    this.entries = cloneJSON(input.entries);
+    this.currentSnapshot = input.snapshot ? cloneJSON(input.snapshot) : void 0;
+  }
+  recordSnapshot(snapshot) {
+    this.currentSnapshot = snapshot;
+    this.snapshots.push(snapshot);
+  }
+  loadSnapshots(snapshots) {
+    this.snapshots = cloneJSON(snapshots);
+    this.currentSnapshot = this.snapshots.at(-1);
+  }
+  filter(filter) {
+    let entries = [...this.entries];
+    if (filter?.id) entries = entries.filter((entry) => entry.id === filter.id);
+    if (filter?.scope) entries = entries.filter((entry) => entry.scope === filter.scope);
+    if (filter?.consume) entries = entries.filter((entry) => entry.consume === filter.consume);
+    if (filter?.providerId) entries = entries.filter((entry) => entry.contribution.providerId === filter.providerId);
+    if (filter?.role) entries = entries.filter((entry) => entry.contribution.authorRole === filter.role || entry.contribution.role === filter.role);
+    if (filter?.on) {
+      const on = eventType(filter.on);
+      entries = entries.filter((entry) => entry.on === on);
+    }
+    return entries;
+  }
+  entriesFor(eventClass, runId, turnId) {
+    const on = eventType(eventClass);
+    return this.entries.filter(
+      (entry) => this.isActive(entry, runId, turnId) && (entry.on === on || entry.activatedAt !== void 0)
+    );
+  }
+  activateFor(eventClass, record, runId, turnId) {
+    const on = eventType(eventClass);
+    this.entries = this.entries.map((entry) => {
+      if (entry.on !== on || entry.activatedAt !== void 0 || !this.isActive(entry, runId, turnId)) return entry;
+      return {
+        ...entry,
+        activatedAt: record.at,
+        activatedByEventId: record.id,
+        activatedByEventType: record.type
+      };
+    });
+  }
+  consume(entries) {
+    const consumed = new Set(entries.filter((entry) => entry.consume === "once" /* Once */).map((entry) => entry.id));
+    if (!consumed.size) return;
+    this.entries = this.entries.filter((entry) => !consumed.has(entry.id));
+  }
+  expireScope(scope, turnId) {
+    this.entries = this.entries.filter((entry) => {
+      if (entry.scope !== scope) return true;
+      if (scope === "turn" /* Turn */ && turnId) return entry.turnId !== turnId;
+      return false;
+    });
+  }
+  addContribution(input) {
+    const options = input.options ?? {};
+    const entry = {
+      id: options.id ?? randomId(),
+      scope: options.scope ?? "run" /* Run */,
+      on: eventType(options.on ?? ModelBeforeEvent),
+      consume: options.consume ?? "once" /* Once */,
+      createdAt: nowIso(),
+      runId: input.runId,
+      turnId: input.turnId,
+      modeId: input.modeId,
+      contribution: input.contribution,
+      metadata: options.metadata
+    };
+    if (options.replace) {
+      this.entries = this.entries.filter((candidate) => candidate.id !== entry.id);
+    } else if (this.entries.some((candidate) => candidate.id === entry.id)) {
+      throw new Error(`Context entry '${entry.id}' already exists. Use replace: true to overwrite it.`);
+    }
+    this.entries.push(entry);
+    return cloneJSON(entry);
+  }
+  remove(id) {
+    const before = this.entries.length;
+    this.entries = this.entries.filter((entry) => entry.id !== id);
+    return this.entries.length !== before;
+  }
+  clear(filter) {
+    const targets = new Set(this.filter(filter).map((entry) => entry.id));
+    this.entries = this.entries.filter((entry) => !targets.has(entry.id));
+    return targets.size;
+  }
+  normalizeProviderInput(input, options, provider, normalize, runId, turnId, modeId) {
+    return this.addContribution({
+      contribution: normalize(input, {
+        providerId: provider?.type,
+        providerLabel: provider?.label
+      }),
+      options,
+      runId,
+      turnId,
+      modeId
+    });
+  }
+  isActive(entry, runId, turnId) {
+    if (entry.scope === "session" /* Session */) return true;
+    if (entry.scope === "run" /* Run */) return entry.runId === runId;
+    if (entry.scope === "turn" /* Turn */) return entry.turnId === turnId;
+    return false;
+  }
+};
+
+// src/runtime/sandbox-manager.ts
+var SandboxManager = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  session;
+  get current() {
+    return this.session;
+  }
+  async ensureOpen() {
+    if (this.session) return this.session;
+    const opened = await this.input.sandbox.open({
+      sessionId: this.input.sessionId,
+      runId: this.input.getRunId(),
+      agentKey: this.input.agentKey,
+      workDir: this.input.workDir,
+      outputDir: this.input.getOutputDir(),
+      services: this.input.services
+    });
+    this.session = this.wrap(opened);
+    this.input.logOpened({ sandboxId: opened.id, workDir: opened.workDir });
+    return this.session;
+  }
+  async close() {
+    const sandbox = this.session;
+    this.session = void 0;
+    if (!sandbox) return;
+    await sandbox.close?.();
+    this.input.logClosed({ sandboxId: sandbox.id });
+  }
+  wrap(base) {
+    const input = this.input;
+    return new class LoggedHarnessSandboxSession extends HarnessSandboxSession {
+      id = base.id;
+      workDir = base.workDir;
+      async exec(commandInput) {
+        const started = performance.now();
+        input.logExecStarted({
+          sandboxId: base.id,
+          command: summarizeValue(commandInput.command),
+          cwd: commandInput.cwd,
+          timeoutMs: commandInput.timeoutMs
+        });
+        try {
+          const result = await base.exec(commandInput);
+          input.logExecCompleted({
+            sandboxId: base.id,
+            exitCode: result.exitCode,
+            signal: result.signal,
+            timedOut: result.timedOut,
+            durationMs: result.durationMs
+          });
+          return result;
+        } catch (error) {
+          input.logExecFailed({
+            sandboxId: base.id,
+            error,
+            durationMs: Math.round(performance.now() - started)
+          });
+          throw error;
+        }
+      }
+      async close() {
+        await base.close?.();
+      }
+    }();
+  }
+};
+
+// src/runtime/storage-coordinator.ts
+var RunStorageCoordinator = class {
+  constructor(input) {
+    this.input = input;
+    this.runIdValue = input.runId;
+    this.storePromise = this.createStore(this.runIdValue);
+  }
+  input;
+  runIdValue;
+  store;
+  storePromise;
+  initialized = false;
+  runtimeLoaded = false;
+  get runDir() {
+    return this.store?.runDir;
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    await this.write("init", (store) => store.init());
+    this.initialized = true;
+  }
+  async loadRuntimeState() {
+    if (this.runtimeLoaded) return void 0;
+    this.runtimeLoaded = true;
+    return {
+      snapshots: await this.write("load_snapshots", (store) => store.loadSnapshots()),
+      contextSnapshots: await this.write("load_context_snapshots", (store) => store.loadContextSnapshots()),
+      transcript: await this.write("load_transcript", (store) => store.loadTranscript()),
+      events: await this.write("load_events", (store) => store.loadEvents()),
+      cursors: await this.write("load_cursors", (store) => store.loadCursors())
+    };
+  }
+  async saveTranscript(messages) {
+    await this.write("save_transcript", (store) => store.saveTranscript(messages));
+  }
+  async saveMetrics(metrics) {
+    await this.write("save_metrics", (store) => store.saveMetrics(metrics));
+  }
+  async saveSnapshot(snapshot) {
+    await this.write("save_snapshot", (store) => store.saveSnapshot(snapshot));
+  }
+  async deleteSnapshot(id) {
+    await this.write("delete_snapshot", (store) => store.deleteSnapshot(id));
+  }
+  async saveContextSnapshot(snapshot) {
+    await this.write("save_context_snapshot", (store) => store.saveContextSnapshot(snapshot));
+  }
+  async recordEvent(event) {
+    await this.write("record_event", (store) => store.recordEvent(event));
+  }
+  async saveCursors(cursors) {
+    await this.write("save_cursors", (store) => store.saveCursors(cursors));
+  }
+  async beginRun(runId) {
+    await this.close();
+    this.runIdValue = runId;
+    this.store = void 0;
+    this.storePromise = this.createStore(runId);
+    this.initialized = false;
+    this.runtimeLoaded = false;
+  }
+  async close() {
+    const store = this.store ?? await this.storePromise;
+    await store.close?.();
+  }
+  async createStore(runId) {
+    try {
+      const store = await this.input.storage.openRun({
+        runId,
+        sessionId: this.input.sessionId,
+        agentKey: this.input.agentKey,
+        outputDir: this.input.outputDir
+      });
+      this.input.logOpened({ storageId: this.input.storage.id, runId, runDir: store.runDir });
+      return store;
+    } catch (error) {
+      this.input.logFailed({ operation: "open_run", error });
+      throw error;
+    }
+  }
+  async getStore() {
+    if (this.store) return this.store;
+    this.store = await this.storePromise;
+    return this.store;
+  }
+  async write(operation, write) {
+    try {
+      return await write(await this.getStore());
+    } catch (error) {
+      this.input.logFailed({ operation, error });
+      throw error;
+    }
+  }
+};
+
+// src/runtime/event-recorder.ts
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var RehydratedHarnessEvent = class extends HarnessEvent {
+};
+var EventRecorder = class {
+  events = [];
+  eventSeq = 0;
+  listeners = /* @__PURE__ */ new Set();
+  get count() {
+    return this.events.length;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  load(records) {
+    if (records.length === 0) return;
+    this.events = records.map((record) => new RehydratedHarnessEvent(record));
+    this.eventSeq = Math.max(0, ...records.map((event) => event.seq));
+  }
+  has(id) {
+    return this.events.some((event) => event.id === id);
+  }
+  latestForBranch(branchId) {
+    let latest;
+    for (const event of this.events) {
+      if (event.record.branchId !== branchId) continue;
+      if (!latest || event.record.seq > latest.record.seq) latest = event;
+    }
+    return latest;
+  }
+  record(input) {
+    const record = {
+      id: randomId(),
+      seq: ++this.eventSeq,
+      branchId: input.branchId,
+      type: input.type,
+      eventClassId: input.type,
+      at: nowIso2(),
+      source: input.source,
+      payload: input.payload,
+      runId: input.runId,
+      turnId: input.turnId,
+      modeId: input.modeId,
+      correlationId: input.correlationId,
+      causationId: input.causationId,
+      hidden: true,
+      metadata: input.metadata
+    };
+    const event = new input.eventClass(record);
+    this.events.push(event);
+    return event;
+  }
+  query(filter, activeSegments) {
+    let events = this.events;
+    if (!filter?.includeInactive) {
+      events = events.filter((event) => {
+        const maxSeq = activeSegments.get(event.record.branchId);
+        return maxSeq !== void 0 && event.record.seq <= maxSeq;
+      });
+    }
+    if (filter?.event) events = events.filter((event) => event.type === eventType(filter.event));
+    if (filter?.type) events = events.filter((event) => event.type === filter.type);
+    if (filter?.sourceKind) events = events.filter((event) => event.record.source.kind === filter.sourceKind);
+    if (filter?.since) events = events.filter((event) => event.at >= filter.since);
+    if (filter?.until) events = events.filter((event) => event.at <= filter.until);
+    if (typeof filter?.limit === "number" && filter.limit > 0) events = events.slice(-filter.limit);
+    return events;
+  }
+  async notify(record) {
+    for (const listener of this.listeners) await listener(record);
+  }
+};
+
+// src/runtime/transcript-manager.ts
+var rootBranchId = "main";
+function nowIso3() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneJSON2(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function createTranscriptCursor(input) {
+  return {
+    id: randomId(),
+    branchId: input?.branchId ?? rootBranchId,
+    headMessageId: input?.headMessageId,
+    seq: input?.seq ?? 0,
+    updatedAt: nowIso3()
+  };
+}
+function createEventCursor(input) {
+  return {
+    id: randomId(),
+    branchId: input?.branchId ?? rootBranchId,
+    headEventId: input?.headEventId,
+    seq: input?.seq ?? 0,
+    updatedAt: nowIso3()
+  };
+}
+var TranscriptManager = class {
+  messages = [];
+  messageSeq = 0;
+  transcriptCursor = createTranscriptCursor();
+  eventCursor = createEventCursor();
+  branches = /* @__PURE__ */ new Map([
+    [rootBranchId, { id: rootBranchId, createdAt: nowIso3() }]
+  ]);
+  get count() {
+    return this.messages.length;
+  }
+  get activeTranscriptCursor() {
+    return this.transcriptCursor;
+  }
+  get activeEventCursor() {
+    return this.eventCursor;
+  }
+  get allMessages() {
+    return this.messages;
+  }
+  get allBranches() {
+    return [...this.branches.values()];
+  }
+  addBranches(branches) {
+    for (const branch of branches) {
+      if (!this.branches.has(branch.id)) this.branches.set(branch.id, cloneJSON2(branch));
+    }
+  }
+  loadTranscript(messages) {
+    if (messages.length === 0) return;
+    this.messages = cloneJSON2(messages);
+    this.messageSeq = Math.max(0, ...messages.map((message) => message.seq));
+  }
+  loadCursors(input) {
+    this.addBranches(input.branches ?? []);
+    const transcriptHead = input.transcriptCursor.headMessageId;
+    const eventHead = input.eventCursor.headEventId;
+    if (!transcriptHead || this.messages.some((message) => message.id === transcriptHead)) {
+      this.transcriptCursor = cloneJSON2(input.transcriptCursor);
+    }
+    if (!eventHead || input.eventExists(eventHead)) {
+      this.eventCursor = cloneJSON2(input.eventCursor);
+    }
+  }
+  restoreCursors(input) {
+    this.addBranches(input.branches ?? []);
+    this.transcriptCursor = cloneJSON2(input.transcriptCursor);
+    this.eventCursor = cloneJSON2(input.eventCursor);
+  }
+  appendMessage(input) {
+    const branchId = input.branchId ?? this.transcriptCursor.branchId;
+    const message = {
+      id: input.id ?? randomId(),
+      seq: ++this.messageSeq,
+      branchId,
+      parentMessageId: this.transcriptCursor.headMessageId,
+      role: input.role,
+      authorRole: input.roleInfo?.authorRole,
+      roleType: input.roleInfo?.roleType,
+      content: input.content,
+      createdAt: input.createdAt ?? nowIso3(),
+      modeId: input.modeId,
+      turnId: input.turnId,
+      hidden: input.hidden,
+      eventCursor: cloneJSON2(this.eventCursor),
+      metadata: input.metadata
+    };
+    this.messages.push(message);
+    this.transcriptCursor = createTranscriptCursor({
+      branchId,
+      headMessageId: message.id,
+      seq: message.seq
+    });
+    return message;
+  }
+  markMessageEventCursor(messageId) {
+    const message = this.messages.find((candidate) => candidate.id === messageId);
+    if (!message) return false;
+    message.eventCursor = cloneJSON2(this.eventCursor);
+    return true;
+  }
+  ensureBranchForAppend() {
+    const cursor = this.transcriptCursor;
+    const latest = this.branchLatestMessage(cursor.branchId);
+    if (!latest || latest.id === cursor.headMessageId) return;
+    const branchId = randomId();
+    const branch = {
+      id: branchId,
+      createdAt: nowIso3(),
+      parentBranchId: cursor.branchId,
+      parentMessageId: cursor.headMessageId,
+      parentMessageSeq: cursor.seq,
+      parentEventSeq: this.eventCursor.seq
+    };
+    this.branches.set(branchId, branch);
+    this.transcriptCursor = createTranscriptCursor({
+      branchId,
+      headMessageId: cursor.headMessageId,
+      seq: cursor.seq
+    });
+    this.eventCursor = createEventCursor({
+      branchId,
+      headEventId: this.eventCursor.headEventId,
+      seq: this.eventCursor.seq
+    });
+  }
+  ensureBranchForEventAppend(latestEvent) {
+    if (!latestEvent || latestEvent.record.seq <= this.eventCursor.seq) return;
+    const branchId = randomId();
+    const branch = {
+      id: branchId,
+      createdAt: nowIso3(),
+      parentBranchId: this.eventCursor.branchId,
+      parentMessageId: this.transcriptCursor.headMessageId,
+      parentMessageSeq: this.transcriptCursor.seq,
+      parentEventSeq: this.eventCursor.seq
+    };
+    this.branches.set(branchId, branch);
+    this.transcriptCursor = createTranscriptCursor({
+      branchId,
+      headMessageId: this.transcriptCursor.headMessageId,
+      seq: this.transcriptCursor.seq
+    });
+    this.eventCursor = createEventCursor({
+      branchId,
+      headEventId: this.eventCursor.headEventId,
+      seq: this.eventCursor.seq
+    });
+  }
+  advanceEventCursor(record) {
+    this.eventCursor = createEventCursor({
+      branchId: record.branchId,
+      headEventId: record.id,
+      seq: record.seq
+    });
+  }
+  filter(options, currentTurnId) {
+    const activeIds = options?.includeInactive ? void 0 : this.activeMessageIds();
+    let messages = activeIds ? this.messages.filter((message) => activeIds.has(message.id)) : [...this.messages];
+    if (!options?.includeHidden) messages = messages.filter((message) => !message.hidden);
+    if (options?.beforeCurrentTurn && currentTurnId) {
+      messages = messages.filter((message) => message.turnId !== currentTurnId);
+    }
+    if (options?.roles?.length) {
+      const allowed = new Set(options.roles);
+      messages = messages.filter((message) => allowed.has(message.role));
+    }
+    messages.sort((a, b) => a.seq - b.seq);
+    if (typeof options?.limit === "number" && options.limit > 0) messages = messages.slice(-options.limit);
+    return messages;
+  }
+  resolveSeekTarget(target) {
+    if (target === "start") {
+      return {
+        transcriptCursor: createTranscriptCursor({ branchId: rootBranchId, seq: 0 }),
+        eventCursor: createEventCursor({ branchId: rootBranchId, seq: 0 })
+      };
+    }
+    if (target === "latest") {
+      const transcriptCursor = this.latestCursorForBranch(this.transcriptCursor.branchId);
+      const head2 = transcriptCursor.headMessageId ? this.messages.find((message) => message.id === transcriptCursor.headMessageId) : void 0;
+      return {
+        transcriptCursor,
+        eventCursor: head2 ? this.eventCursorForMessage(head2) : this.eventCursor
+      };
+    }
+    if ("messageId" in target) {
+      const message = this.messages.find((candidate) => candidate.id === target.messageId);
+      if (!message) throw new Error(`Transcript message '${target.messageId}' was not found.`);
+      return {
+        transcriptCursor: createTranscriptCursor({
+          branchId: message.branchId,
+          headMessageId: message.id,
+          seq: message.seq
+        }),
+        eventCursor: this.eventCursorForMessage(message)
+      };
+    }
+    const head = target.cursor.headMessageId ? this.messages.find((message) => message.id === target.cursor.headMessageId) : void 0;
+    return {
+      transcriptCursor: cloneJSON2(target.cursor),
+      eventCursor: head ? this.eventCursorForMessage(head) : createEventCursor({
+        branchId: target.cursor.branchId,
+        seq: 0
+      })
+    };
+  }
+  applyResolvedSeek(resolved) {
+    this.transcriptCursor = resolved.transcriptCursor;
+    this.eventCursor = resolved.eventCursor;
+  }
+  activeEventSegments(cursor = this.eventCursor) {
+    const segments = /* @__PURE__ */ new Map();
+    let branchId = cursor.branchId;
+    let maxSeq = cursor.seq;
+    while (branchId) {
+      const existing = segments.get(branchId);
+      segments.set(branchId, existing === void 0 ? maxSeq : Math.max(existing, maxSeq));
+      const branch = this.branches.get(branchId);
+      if (!branch?.parentBranchId) break;
+      branchId = branch.parentBranchId;
+      maxSeq = branch.parentEventSeq ?? 0;
+    }
+    return segments;
+  }
+  activeMessageIds(cursor = this.transcriptCursor) {
+    const byId = new Map(this.messages.map((message) => [message.id, message]));
+    const active = /* @__PURE__ */ new Set();
+    let current = cursor.headMessageId ? byId.get(cursor.headMessageId) : void 0;
+    while (current) {
+      if (current.seq > cursor.seq) break;
+      active.add(current.id);
+      current = current.parentMessageId ? byId.get(current.parentMessageId) : void 0;
+    }
+    return active;
+  }
+  branchLatestMessage(branchId) {
+    let latest;
+    for (const message of this.messages) {
+      if (message.branchId !== branchId) continue;
+      if (!latest || message.seq > latest.seq) latest = message;
+    }
+    return latest;
+  }
+  eventCursorForMessage(message) {
+    return message.eventCursor ? cloneJSON2(message.eventCursor) : createEventCursor({
+      branchId: message.branchId,
+      seq: this.eventCursor.seq,
+      headEventId: this.eventCursor.headEventId
+    });
+  }
+  latestCursorForBranch(branchId) {
+    const latest = this.branchLatestMessage(branchId);
+    const branch = this.branches.get(branchId);
+    return createTranscriptCursor({
+      branchId,
+      headMessageId: latest?.id ?? branch?.parentMessageId,
+      seq: latest?.seq ?? branch?.parentMessageSeq ?? 0
+    });
+  }
+};
+
+// src/runtime/role-resolver.ts
+var RoleResolver = class {
+  constructor(roles, input) {
+    this.roles = roles;
+    this.input = input;
+  }
+  roles;
+  input;
+  resolve(selector) {
+    const definition = this.definitionFromSelector(selector);
+    if (!definition) {
+      if (typeof selector !== "string") throw new Error(`Unknown role '${getConstructType(selector)}'.`);
+      return {
+        role: selector,
+        authorRole: selector,
+        roleType: selector,
+        target: selector === "system" /* System */ ? "system" /* System */ : "messages" /* Messages */
+      };
+    }
+    return {
+      role: definition.nativeRole ?? getRoleName(definition),
+      authorRole: getRoleName(definition),
+      roleType: getConstructType(definition),
+      target: definition.target,
+      definition
+    };
+  }
+  assertModelProviderSupportsMessages(messages) {
+    for (const message of messages) {
+      if (message.hidden || message.role === "event") continue;
+      this.assertModelProviderSupportsRole(message.role);
+    }
+  }
+  summary(role) {
+    return {
+      type: getConstructType(role),
+      name: getRoleName(role),
+      label: getConstructLabel(role),
+      target: role.target,
+      nativeRole: role.nativeRole,
+      default: role.default,
+      description: role.description
+    };
+  }
+  definitionFromSelector(selector) {
+    const registered = this.roles.find((role) => roleMatchesSelector(role, selector));
+    if (registered) return registered;
+    if (typeof selector === "string") return void 0;
+    if (isRoleInstance(selector)) return selector;
+    if (isRoleClass(selector)) {
+      try {
+        return new selector();
+      } catch {
+        throw new Error(`Role '${getConstructType(selector)}' must be registered as an instance or have a zero-argument constructor.`);
+      }
+    }
+    return void 0;
+  }
+  assertModelProviderSupportsRole(role) {
+    const supportsRole = this.input.supportsRole;
+    if (supportsRole && !supportsRole(role)) {
+      throw new Error(`Model provider '${this.input.modelProviderId}' does not support native role '${role}'.`);
+    }
+  }
+};
+
+// src/runtime/tool-executor.ts
+function invalidFieldsFromIssues(issues) {
+  return issues.map((entry) => ({
+    path: entry.path,
+    message: entry.message,
+    code: entry.code,
+    expected: entry.expected,
+    received: entry.received
+  }));
+}
+function safeParseWithSchema(schema, payload2) {
+  const normalized = normalizeSchema(schema);
+  const result = normalized.safeParse(payload2);
+  if (result.success) return { ok: true, data: result.data };
+  const issues = normalized.issuesFromError(result.error);
+  return { ok: false, error: result.error, issues, invalidFields: invalidFieldsFromIssues(issues) };
+}
+function isEmptyToolArgs(args) {
+  return args == null || typeof args === "object" && !Array.isArray(args) && Object.keys(args).length === 0;
+}
+function ensureToolMetric(metrics, name) {
+  const existing = metrics.tools[name];
+  if (existing) return existing;
+  const metric = { name, count: 0, errorCount: 0, totalDurationMs: 0 };
+  metrics.tools[name] = metric;
+  return metric;
+}
+var ToolExecutor = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  depth = 0;
+  async execute(input) {
+    if (this.depth > 8) throw new Error("Tool invocation depth exceeded.");
+    const source = input.source ?? { kind: "runtime" };
+    const id = input.callId ?? randomId();
+    const toolSource = { kind: "tool", id, name: input.tool.name };
+    const start = performance.now();
+    const metrics = this.input.getMetrics();
+    const metric = ensureToolMetric(metrics, input.tool.name);
+    metric.count++;
+    metrics.toolCallCount++;
+    await this.input.addToolCallMessage(input.tool, input.args, id, source);
+    this.input.log(
+      ToolStartedLog,
+      { toolName: input.tool.name, args: summarizeValue(input.args), risk: input.tool.risk },
+      toolSource,
+      id,
+      input.parentCausationId ?? input.parentCorrelationId
+    );
+    if (isEmptyToolArgs(input.args)) {
+      this.input.log(ToolArgsEmptyLog, { toolName: input.tool.name }, toolSource, id, input.parentCausationId ?? input.parentCorrelationId);
+    }
+    const startEvent = await this.input.emitInternal(ToolStartEvent, { id, name: input.tool.name, args: input.args }, {
+      source,
+      correlationId: id,
+      causationId: input.parentCausationId ?? input.parentCorrelationId
+    });
+    const toolEventOptions = {
+      source: toolSource,
+      correlationId: id,
+      causationId: startEvent.id
+    };
+    const callerEventOptions = {
+      source,
+      correlationId: id,
+      causationId: startEvent.id
+    };
+    const parsedArgs = safeParseWithSchema(input.tool.inputSchema, input.args);
+    if (!parsedArgs.ok) {
+      const result = this.structuredToolError({
+        toolName: input.tool.name,
+        code: "tool.args.invalid_schema",
+        message: "Tool arguments did not match schema.",
+        invalidFields: parsedArgs.invalidFields
+      });
+      const durationMs = Math.round(performance.now() - start);
+      metric.errorCount++;
+      metric.totalDurationMs += durationMs;
+      metrics.errors.push(result.content);
+      this.input.log(
+        ToolInvalidSchemaLog,
+        { toolName: input.tool.name, issues: parsedArgs.issues },
+        toolSource,
+        id,
+        startEvent.id,
+        { durationMs }
+      );
+      await this.input.addToolResultMessage(input.tool, result, id);
+      await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result }, callerEventOptions);
+      this.input.throwIfTurnHandoffRequested();
+      return result;
+    }
+    const approved = await this.approveTool(
+      { id, name: input.tool.name, args: parsedArgs.data, modeId: this.input.getCurrentMode(), risk: input.tool.risk, permissions: input.tool.permissions },
+      input.tool,
+      parsedArgs.data,
+      callerEventOptions
+    );
+    if (!approved) {
+      const denied = this.structuredToolError({
+        toolName: input.tool.name,
+        code: "tool.approval.denied",
+        message: `Tool '${input.tool.name}' was denied by runner policy.`,
+        metadata: { denied: true }
+      });
+      metric.errorCount++;
+      const durationMs = Math.round(performance.now() - start);
+      metric.totalDurationMs += durationMs;
+      this.input.log(ToolFailedLog, {
+        toolName: input.tool.name,
+        durationMs,
+        result: summarizeValue(denied)
+      }, toolSource, id, startEvent.id, { durationMs });
+      await this.input.addToolResultMessage(input.tool, denied, id);
+      await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result: denied }, callerEventOptions);
+      this.input.throwIfTurnHandoffRequested();
+      return denied;
+    }
+    this.depth++;
+    try {
+      await this.input.ensureSandboxOpen();
+      const executed = await input.tool.execute(parsedArgs.data, this.input.buildActionSession({ id, name: input.tool.name }, toolSource, id, startEvent.id));
+      const result = this.ensureStructuredToolErrorResult(input.tool, executed);
+      const durationMs = Math.round(performance.now() - start);
+      metric.totalDurationMs += durationMs;
+      if (result.isError) metric.errorCount++;
+      if (result.isError) {
+        this.input.log(ToolFailedLog, {
+          toolName: input.tool.name,
+          durationMs,
+          result: summarizeValue(result)
+        }, toolSource, id, startEvent.id, { durationMs });
+      } else {
+        this.input.log(ToolCompletedLog, {
+          toolName: input.tool.name,
+          durationMs,
+          isError: false,
+          result: summarizeValue(result)
+        }, toolSource, id, startEvent.id, { durationMs });
+      }
+      await this.input.addToolResultMessage(input.tool, result, id);
+      await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result }, callerEventOptions);
+      this.input.throwIfTurnHandoffRequested();
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const result = this.structuredToolError({
+        toolName: input.tool.name,
+        code: "tool.failed",
+        message: "Tool execution failed.",
+        metadata: { error: true }
+      });
+      const durationMs = Math.round(performance.now() - start);
+      metric.errorCount++;
+      metric.totalDurationMs += durationMs;
+      metrics.errors.push(message);
+      this.input.log(ToolFailedLog, {
+        toolName: input.tool.name,
+        durationMs,
+        error
+      }, toolSource, id, startEvent.id, { durationMs });
+      await this.input.addToolResultMessage(input.tool, result, id);
+      await this.input.emitInternal(ErrorEvent, { message, details: error }, toolEventOptions);
+      await this.input.emitInternal(ToolEndEvent, { id, name: input.tool.name, durationMs, result }, callerEventOptions);
+      this.input.throwIfTurnHandoffRequested();
+      return result;
+    } finally {
+      this.depth--;
+    }
+  }
+  structuredToolError(input) {
+    return {
+      content: input.message,
+      data: createToolErrorPayload({
+        code: input.code,
+        message: input.message,
+        toolName: input.toolName,
+        invalidFields: input.invalidFields
+      }),
+      isError: true,
+      metadata: {
+        errorCode: input.code,
+        ...input.invalidFields ? { invalidFields: input.invalidFields } : {},
+        ...input.metadata ?? {}
+      }
+    };
+  }
+  ensureStructuredToolErrorResult(tool, result) {
+    if (!result.isError || result.data !== void 0) return result;
+    return {
+      ...result,
+      data: createToolErrorPayload({
+        code: "tool.failed",
+        message: result.content || "Tool execution failed.",
+        toolName: tool.name
+      }),
+      metadata: {
+        ...result.metadata,
+        errorCode: result.metadata?.errorCode ?? "tool.failed"
+      }
+    };
+  }
+  async approveTool(request, tool, args, eventOptions) {
+    const policy = this.input.getToolApprovalMode() ?? "tool-default";
+    if (policy === "auto") return this.recordApprovalResolution(request, "approved", eventOptions);
+    if (policy === "deny") return this.recordApprovalResolution(request, "denied", eventOptions);
+    const requiresApproval = await this.toolRequiresApproval(tool, args, request.id, eventOptions.causationId);
+    if (policy === "tool-default" && !requiresApproval) return true;
+    await this.input.emitInternal(
+      ToolApprovalRequestedEvent,
+      {
+        id: request.id,
+        name: request.name,
+        args: request.args,
+        modeId: request.modeId,
+        risk: request.risk,
+        permissions: request.permissions
+      },
+      eventOptions
+    );
+    this.input.log(
+      ToolApprovalRequestedLog,
+      { toolName: request.name, risk: request.risk, permissions: request.permissions },
+      eventOptions.source,
+      eventOptions.correlationId,
+      eventOptions.causationId
+    );
+    if (!this.input.approveTool) return this.recordApprovalResolution(request, "denied", eventOptions);
+    const decision = await this.input.approveTool(request);
+    return this.recordApprovalResolution(request, decision === true || decision === "approved" ? "approved" : "denied", eventOptions);
+  }
+  async toolRequiresApproval(tool, args, toolCallId, causationId) {
+    if (typeof tool.requiresApproval === "function") {
+      await this.input.ensureSandboxOpen();
+      return tool.requiresApproval(
+        args,
+        this.input.buildActionSession(
+          { id: toolCallId, name: tool.name },
+          { kind: "tool", id: toolCallId, name: tool.name },
+          toolCallId,
+          causationId
+        )
+      );
+    }
+    return tool.requiresApproval === true;
+  }
+  async recordApprovalResolution(request, decision, eventOptions) {
+    await this.input.emitInternal(
+      ToolApprovalResolvedEvent,
+      { id: request.id, name: request.name, args: request.args, decision, modeId: request.modeId },
+      eventOptions
+    );
+    this.input.log(
+      ToolApprovalResolvedLog,
+      { toolName: request.name, approved: decision === "approved" },
+      eventOptions.source,
+      eventOptions.correlationId,
+      eventOptions.causationId
+    );
+    return decision === "approved";
+  }
+};
+
+// src/runtime/snapshot-manager.ts
+function cloneJSON3(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var SnapshotManager = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  snapshots = [];
+  load(snapshot) {
+    if (!this.snapshots.some((candidate) => candidate.id === snapshot.id)) {
+      this.snapshots.push(cloneJSON3(snapshot));
+    }
+  }
+  add(snapshot) {
+    this.snapshots.push(snapshot);
+  }
+  get(id) {
+    const snapshot = this.snapshots.find((candidate) => candidate.id === id);
+    return snapshot ? cloneJSON3(snapshot) : void 0;
+  }
+  getRaw(id) {
+    return this.snapshots.find((candidate) => candidate.id === id);
+  }
+  async create(input = {}, eventOptions) {
+    const manager = this.requireInput();
+    await manager.ensureStoreInitialized();
+    const snapshot = {
+      id: randomId(),
+      label: input.label,
+      createdAt: manager.now(),
+      ...cloneJSON3(manager.readState()),
+      metadata: input.metadata
+    };
+    this.add(snapshot);
+    await manager.saveSnapshot(snapshot);
+    const summary = this.summary(snapshot);
+    await manager.emitCreated(summary, eventOptions);
+    manager.logCreated(summary, eventOptions);
+    return cloneJSON3(snapshot);
+  }
+  async restore(id, eventOptions) {
+    const manager = this.requireInput();
+    await manager.ensureStoreInitialized();
+    const snapshot = this.getRaw(id);
+    if (!snapshot) {
+      manager.logRestoreRejected(id, "not_found", eventOptions);
+      throw new Error(`Snapshot '${id}' was not found.`);
+    }
+    manager.restoreState(snapshot);
+    const summary = this.summary(snapshot);
+    await manager.emitRestored(summary, eventOptions);
+    manager.logRestored(summary, eventOptions);
+    await manager.persistCursors();
+    return cloneJSON3(snapshot);
+  }
+  list() {
+    return cloneJSON3(this.snapshots.map((snapshot) => this.summary(snapshot)));
+  }
+  delete(id) {
+    const snapshot = this.snapshots.find((candidate) => candidate.id === id);
+    if (!snapshot) return void 0;
+    this.snapshots = this.snapshots.filter((candidate) => candidate.id !== id);
+    return snapshot;
+  }
+  async deletePersisted(id, eventOptions) {
+    const manager = this.requireInput();
+    await manager.ensureStoreInitialized();
+    const snapshot = this.delete(id);
+    if (!snapshot) return false;
+    await manager.deleteSnapshot(id);
+    const summary = this.summary(snapshot);
+    await manager.emitDeleted(summary, eventOptions);
+    manager.logDeleted(summary, eventOptions);
+    return true;
+  }
+  summary(snapshot) {
+    return {
+      id: snapshot.id,
+      label: snapshot.label,
+      createdAt: snapshot.createdAt,
+      agentKey: snapshot.agentKey,
+      runId: snapshot.runId,
+      turnId: snapshot.turnId,
+      modeId: snapshot.modeId,
+      model: snapshot.model,
+      transcriptCursor: cloneJSON3(snapshot.transcriptCursor),
+      eventCursor: cloneJSON3(snapshot.eventCursor),
+      metadata: snapshot.metadata
+    };
+  }
+  requireInput() {
+    if (!this.input) throw new Error("SnapshotManager operation requires runtime dependencies.");
+    return this.input;
+  }
+};
+
+// src/runtime/model-pipeline.ts
+var ModelPipeline = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  async run(input) {
+    const prepared = await this.prepareContext(input.mode, input.userMessage);
+    const systemPrompt = prepared.systemPrompt;
+    const messages = prepared.messages;
+    const model = this.input.getModel();
+    const resolved = this.input.resolveModelProvider(model);
+    const source = this.modelProviderSource(resolved);
+    try {
+      const modelStart = performance.now();
+      this.input.log(ModelCallStartedLog, { model, messageCount: messages.length }, source);
+      const result = await resolved.provider.run({
+        runId: this.input.getRunId(),
+        turnId: this.input.getTurnId(),
+        modeId: this.input.getModeId(),
+        modelRef: resolved.modelRef,
+        provider: resolved.namespace,
+        model: resolved.modelId,
+        systemPrompt,
+        messages,
+        roles: this.input.roles,
+        tools: input.tools,
+        maxTurns: input.mode.maxTurns ?? 20,
+        signal: input.options.signal,
+        prepareContext: () => this.prepareContext(input.mode, input.userMessage),
+        emit: async (eventClass, payload2, options) => {
+          const event = await this.input.emit(
+            eventClass,
+            payload2,
+            this.input.withEmitDefaults(source, void 0, void 0, options)
+          );
+          this.input.throwIfTurnHandoffRequested();
+          return event;
+        },
+        executeTool: (tool, args, callId) => this.input.executeTool(tool, args, callId, source)
+      });
+      const assistantMessage = await this.input.addAssistantMessage(result.content, {
+        usage: result.usage,
+        finishReason: result.finishReason
+      });
+      this.input.setFinalAnswer(result.content);
+      this.input.getMetrics().usage = result.usage;
+      await this.input.emitInternal(MessageEndEvent, { message: assistantMessage });
+      await this.input.markMessageEventCursor(assistantMessage.id);
+      this.input.log(ModelCallCompletedLog, {
+        model,
+        durationMs: Math.round(performance.now() - modelStart),
+        finishReason: result.finishReason
+      }, source);
+      await this.input.emitInternal(ModelAfterEvent, {
+        model,
+        content: result.content,
+        usage: result.usage,
+        finishReason: result.finishReason
+      });
+      this.input.throwIfTurnHandoffRequested();
+    } catch (error) {
+      if (this.input.isTurnHandoffSignal(error)) return;
+      const message = error instanceof Error ? error.message : String(error);
+      this.input.getMetrics().errors.push(message);
+      this.input.log(ModelCallFailedLog, { model, error }, source);
+      await this.input.emitInternal(ErrorEvent, { message, details: error });
+      throw error;
+    }
+  }
+  modelProviderSource(resolved) {
+    const id = modelProviderId(resolved.provider);
+    return { kind: "model_provider", id, name: id };
+  }
+  async resolveModePrompt(mode) {
+    const source = { kind: "mode", id: getConstructType(mode), name: getConstructLabel(mode) };
+    if (typeof mode.getPrompt === "function") return mode.getPrompt(this.input.buildReadSession(source));
+    if (typeof mode.prompt === "function") return mode.prompt(this.input.buildReadSession(source));
+    return mode.prompt ?? "";
+  }
+  async prepareContext(mode, userMessage) {
+    const contextSnapshot = await this.input.buildContextSnapshot(ModelBeforeEvent);
+    const prompt = await this.resolveModePrompt(mode);
+    const systemPrompt = [contextSnapshot.systemPrompt, prompt].filter(Boolean).join("\n\n---\n\n");
+    const messages = [...contextSnapshot.messages, userMessage];
+    this.input.assertModelProviderSupportsMessages(messages);
+    await this.input.emitInternal(ContextReadyEvent, {
+      snapshotId: contextSnapshot.id,
+      providerCount: contextSnapshot.providers.length,
+      contributionCount: contextSnapshot.contributions.length
+    });
+    await this.input.emitInternal(ModelBeforeEvent, { model: this.input.getModel(), messageCount: messages.length });
+    this.input.throwIfTurnHandoffRequested();
+    return {
+      systemPrompt,
+      messages,
+      snapshot: contextSnapshot
+    };
+  }
+};
+
+// src/runtime/runner.ts
+function nowIso4() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneJSON4(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var TurnHandoffSignal = class extends Error {
+  constructor() {
+    super("Turn handoff requested.");
+    this.name = "TurnHandoffSignal";
+  }
+};
+function defaultRoles() {
+  return [systemRole, userRole, assistantRole, toolRole];
+}
+function emptyMetrics() {
+  return {
+    startedAt: nowIso4(),
+    durationMs: 0,
+    turnCount: 0,
+    messageCount: 0,
+    eventCount: 0,
+    toolCallCount: 0,
+    tools: {},
+    errors: []
+  };
+}
+function stringifyContent(content) {
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+  return JSON.stringify(content, null, 2);
+}
+function normalizeAgentMessageInput(input) {
+  return typeof input === "string" ? { content: input } : input;
+}
+var noopAgentLogSession = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  emit: () => void 0
+};
+function keyFromLabel(label) {
+  const key = label.trim().replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^a-zA-Z0-9]+/gu, "-").replace(/^-|-$/gu, "").toLowerCase();
+  return key || "agent";
+}
+function ensureNoLegacyAgentShape(agent) {
+  const candidate = agent;
+  if ("id" in candidate) throw new Error("Agent definitions no longer declare id. Use optional key for packaging metadata.");
+  if ("events" in candidate) throw new Error("Agent definitions no longer declare events. Emit and query event classes directly.");
+  if ("contextProviders" in candidate) {
+    throw new Error("Agent definitions no longer declare contextProviders. Attach providers to modes directly.");
+  }
+  if (!Array.isArray(candidate.modes)) {
+    throw new Error("Agent modes must be an array of HarnessMode instances. Object-literal mode maps are not supported.");
+  }
+  if (typeof candidate.initialMode === "string") {
+    throw new Error("Agent initialMode must be a HarnessMode class or instance, not a string id.");
+  }
+}
+function validateMode(mode) {
+  if (!isModeInstance(mode)) throw new Error("Agent modes must extend HarnessMode.");
+  assertNoAuthorId(mode, "Mode");
+  if ("context" in mode) {
+    throw new Error(`Mode '${getConstructType(mode)}' uses context. Declare providers directly on the mode class.`);
+  }
+  if ("lifecycle" in mode) {
+    throw new Error(`Mode '${getConstructType(mode)}' uses lifecycle. Put onEnter/onExit methods directly on the class.`);
+  }
+  if (mode.prompt === void 0 && typeof mode.getPrompt !== "function") {
+    throw new Error(`Mode '${getConstructType(mode)}' must define prompt or getPrompt(ctx).`);
+  }
+}
+function validateRoles(roles) {
+  if (!roles) return void 0;
+  for (const role of roles) {
+    if (!isRoleInstance(role)) throw new Error("Agent roles must extend HarnessRole.");
+    assertNoAuthorId(role, "Role");
+  }
+  return roles;
+}
+function validateHooks(hooks) {
+  if (!hooks) return void 0;
+  for (const hook of hooks) {
+    if (!isHookInstance(hook)) throw new Error("Agent hooks must extend HarnessHook.");
+    assertNoAuthorId(hook, "Hook");
+    if (!hookEventClass(hook)) {
+      throw new Error(`Hook '${getConstructType(hook)}' must extend HarnessHook.for(EventClass).`);
+    }
+  }
+  return hooks;
+}
+function validateDeclaredEvents(events) {
+  if (!events) return void 0;
+  for (const eventClass of events) eventType(eventClass);
+  return events;
+}
+function resolveInitialModeType(selector, modes) {
+  for (const mode of Object.values(modes)) {
+    if (modeMatchesSelector(mode, selector)) return getConstructType(mode);
+  }
+  throw new Error(`Unknown initial mode '${getConstructType(selector)}'.`);
+}
+function normalizeAgent(definition) {
+  ensureNoLegacyAgentShape(definition);
+  const modes = {};
+  for (const mode of definition.modes) {
+    validateMode(mode);
+    const type = getConstructType(mode);
+    if (modes[type]) throw new Error(`Duplicate mode type '${type}'.`);
+    modes[type] = mode;
+  }
+  const initialMode = resolveInitialModeType(definition.initialMode, modes);
+  const key = definition.key ?? keyFromLabel(definition.label);
+  return {
+    key,
+    label: definition.label,
+    initialMode,
+    modes,
+    sharedState: definition.sharedState,
+    roles: validateRoles(definition.roles),
+    hooks: validateHooks(definition.hooks),
+    declaredEvents: validateDeclaredEvents(definition.declaredEvents)
+  };
+}
+var AgentSessionRunner = class {
+  constructor(options) {
+    this.options = options;
+    this.agent = normalizeAgent(options.agent);
+    this.sessionIdValue = options.sessionId ?? randomId();
+    this.workDir = options.workDir ?? ".";
+    this.outputDir = options.outputDir ?? ".harness-kernel/runs";
+    const storage = options.storage ?? new NoopRunStorage();
+    const sandbox = options.sandbox ?? new NoopSandbox();
+    this.providerRegistry = new HarnessModelProviderRegistry(options.providers);
+    this.currentMode = options.initialMode ? this.resolveModeType(options.initialMode) : this.agent.initialMode;
+    this.services = options.services ?? {};
+    this.roles = validateRoles(options.roles) ?? this.agent.roles ?? defaultRoles();
+    const initialProvider = this.resolveModelProvider(options.defaultModel).provider;
+    this.roleResolver = new RoleResolver(this.roles, {
+      modelProviderId: modelProviderId(initialProvider),
+      supportsRole: (roleId) => this.resolveModelProvider(this.getActiveModel()).provider.supportsRole?.(roleId) ?? true
+    });
+    this.defaultModel = options.defaultModel;
+    this.storageCoordinator = new RunStorageCoordinator({
+      storage,
+      runId: this.runIdValue,
+      sessionId: this.sessionIdValue,
+      agentKey: this.agent.key,
+      outputDir: this.outputDir,
+      logOpened: (fields) => this.log(RunStorageOpenedLog, fields),
+      logFailed: (fields) => this.log(StorageWriteFailedLog, fields)
+    });
+    this.snapshotManager = new SnapshotManager({
+      now: () => nowIso4(),
+      ensureStoreInitialized: () => this.ensureStoreInitialized(),
+      readState: () => ({
+        agentKey: this.agent.key,
+        runId: this.started ? this.runId : void 0,
+        turnId: this.currentTurnId,
+        modeId: this.currentMode,
+        model: this.getActiveModel(),
+        transcriptCursor: cloneJSON4(this.transcriptManager.activeTranscriptCursor),
+        eventCursor: cloneJSON4(this.transcriptManager.activeEventCursor),
+        state: cloneJSON4(this.state),
+        contextEntries: cloneJSON4(this.contextRegistry.allEntries),
+        contextSnapshot: this.contextRegistry.current ? cloneJSON4(this.contextRegistry.current) : void 0,
+        branches: cloneJSON4(this.transcriptManager.allBranches)
+      }),
+      restoreState: (snapshot) => {
+        this.currentMode = snapshot.modeId;
+        this.modelOverride = snapshot.model;
+        this.state = cloneJSON4(snapshot.state);
+        this.contextRegistry.restore({
+          entries: snapshot.contextEntries,
+          snapshot: snapshot.contextSnapshot
+        });
+        this.transcriptManager.restoreCursors({
+          transcriptCursor: snapshot.transcriptCursor,
+          eventCursor: snapshot.eventCursor,
+          branches: snapshot.branches
+        });
+      },
+      persistCursors: () => this.persistCursors(),
+      saveSnapshot: (snapshot) => this.storageCoordinator.saveSnapshot(snapshot),
+      deleteSnapshot: (id) => this.storageCoordinator.deleteSnapshot(id),
+      emitCreated: async (summary, eventOptions) => {
+        await this.emitInternal(SnapshotCreatedEvent, { snapshot: summary }, {
+          ...eventOptions,
+          hiddenTranscript: false
+        });
+      },
+      emitRestored: async (summary, eventOptions) => {
+        await this.emitInternal(SnapshotRestoredEvent, { snapshot: summary }, {
+          ...eventOptions,
+          hiddenTranscript: false
+        });
+      },
+      emitDeleted: async (summary, eventOptions) => {
+        await this.emitInternal(SnapshotDeletedEvent, { snapshot: summary }, {
+          ...eventOptions,
+          hiddenTranscript: false
+        });
+      },
+      logCreated: (summary, eventOptions) => this.log(
+        SnapshotCreatedLog,
+        { snapshotId: summary.id, label: summary.label },
+        eventOptions?.source,
+        eventOptions?.correlationId,
+        eventOptions?.causationId
+      ),
+      logRestored: (summary, eventOptions) => this.log(
+        SnapshotRestoredLog,
+        { snapshotId: summary.id, label: summary.label },
+        eventOptions?.source,
+        eventOptions?.correlationId,
+        eventOptions?.causationId
+      ),
+      logDeleted: (summary, eventOptions) => this.log(
+        SnapshotDeletedLog,
+        { snapshotId: summary.id, label: summary.label },
+        eventOptions?.source,
+        eventOptions?.correlationId,
+        eventOptions?.causationId
+      ),
+      logRestoreRejected: (snapshotId, reason, eventOptions) => this.log(
+        SnapshotRestoreRejectedLog,
+        { snapshotId, reason },
+        eventOptions?.source,
+        eventOptions?.correlationId,
+        eventOptions?.causationId
+      )
+    });
+    this.sandboxManager = new SandboxManager({
+      sandbox,
+      sessionId: this.sessionIdValue,
+      agentKey: this.agent.key,
+      workDir: this.workDir,
+      services: this.services,
+      getRunId: () => this.runId,
+      getOutputDir: () => this.storeRunDir(),
+      logOpened: (fields) => this.log(SandboxOpenedLog, fields),
+      logClosed: (fields) => this.log(SandboxClosedLog, fields),
+      logExecStarted: (fields) => this.log(SandboxExecStartedLog, fields),
+      logExecCompleted: (fields) => this.log(SandboxExecCompletedLog, fields),
+      logExecFailed: (fields) => this.log(SandboxExecFailedLog, fields)
+    });
+    this.toolExecutor = new ToolExecutor({
+      getMetrics: () => this.metrics,
+      getCurrentMode: () => this.currentMode,
+      getToolApprovalMode: () => this.options.toolApproval ?? this.getModeDefinition(this.currentMode).toolApproval,
+      approveTool: this.options.approveTool,
+      ensureSandboxOpen: () => this.ensureSandboxOpen(),
+      buildActionSession: (tool, source, correlationId, causationId) => this.buildActionSession(tool, source, correlationId, causationId),
+      addToolCallMessage: (tool, args, toolCallId, source) => this.addToolCallMessage(tool, args, toolCallId, source),
+      addToolResultMessage: (tool, result, toolCallId) => this.addToolResultMessage(tool, result, toolCallId),
+      emitInternal: (eventClass, payload2, options2) => this.emitInternal(eventClass, payload2, options2),
+      log: (logClass, fields, source, correlationId, causationId, overrides) => this.log(logClass, fields, source, correlationId, causationId, overrides),
+      throwIfTurnHandoffRequested: () => this.throwIfTurnHandoffRequested()
+    });
+    this.modelPipeline = new ModelPipeline({
+      resolveModelProvider: (model) => this.resolveModelProvider(model),
+      roles: this.roles,
+      getRunId: () => this.runId,
+      getTurnId: () => this.currentTurnId,
+      getModeId: () => this.currentMode,
+      getModel: () => this.getActiveModel(),
+      getMetrics: () => this.metrics,
+      setFinalAnswer: (answer) => {
+        this.finalAnswer = answer;
+      },
+      buildReadSession: (source) => this.buildReadSession(source),
+      buildContextSnapshot: (trigger) => this.buildContextSnapshot(trigger),
+      assertModelProviderSupportsMessages: (messages) => this.assertModelProviderSupportsMessages(messages),
+      addAssistantMessage: (content, metadata) => this.addMessage("assistant", content, metadata),
+      markMessageEventCursor: (messageId) => this.markMessageEventCursor(messageId),
+      executeTool: (tool, args, callId, source) => this.executeTool(tool, args, callId, source),
+      emitInternal: (eventClass, payload2, eventOptions) => this.emitInternal(eventClass, payload2, eventOptions),
+      emit: (eventClass, payload2, eventOptions) => this.emit(eventClass, payload2, eventOptions),
+      withEmitDefaults: (source, correlationId, causationId, eventOptions) => this.withEmitDefaults(source, correlationId, causationId, eventOptions),
+      log: (logClass, fields, source, correlationId, causationId, overrides) => this.log(logClass, fields, source, correlationId, causationId, overrides),
+      throwIfTurnHandoffRequested: () => this.throwIfTurnHandoffRequested(),
+      isTurnHandoffSignal: (error) => error instanceof TurnHandoffSignal
+    });
+    this.state = this.createInitialState(this.agent);
+    for (const eventClass of runtimeEventClasses) eventType(eventClass);
+  }
+  options;
+  agent;
+  workDir;
+  outputDir;
+  sessionIdValue;
+  storageCoordinator;
+  sandboxManager;
+  runIdValue = randomId();
+  transcriptManager = new TranscriptManager();
+  eventRecorder = new EventRecorder();
+  contextRegistry = new ContextRegistry();
+  snapshotManager;
+  toolExecutor;
+  modelPipeline;
+  services;
+  roles;
+  roleResolver;
+  providerRegistry;
+  defaultModel;
+  modelOverride;
+  runModelOverride;
+  currentMode;
+  state;
+  metrics = emptyMetrics();
+  startedAtPerf = 0;
+  started = false;
+  pendingInputs = [];
+  finalAnswer = "";
+  currentTurnId;
+  providerStack = [];
+  hookDepth = 0;
+  turnHandoffRequested = false;
+  logSource(source) {
+    if (!source) return { kind: "runtime" };
+    return {
+      kind: source.kind,
+      type: source.id,
+      name: source.name,
+      label: source.name
+    };
+  }
+  logContext(source, correlationId, causationId, overrides = {}) {
+    return {
+      sessionId: this.sessionIdValue,
+      runId: this.runId,
+      turnId: this.currentTurnId,
+      modeId: this.currentMode,
+      branchId: this.transcriptManager.activeTranscriptCursor.branchId,
+      source: this.logSource(source),
+      correlationId,
+      causationId,
+      ...overrides
+    };
+  }
+  log(logClass, fields, source, correlationId, causationId, overrides) {
+    this.options.logger?.emit(logClass, fields, this.logContext(source, correlationId, causationId, overrides));
+  }
+  logModelDelta(payload2, options) {
+    const policy = this.options.logger?.modelDeltas ?? "none";
+    if (policy === "none") return;
+    const text = payload2 && typeof payload2 === "object" && "text" in payload2 ? String(payload2.text ?? "") : "";
+    this.log(
+      ModelDeltaLog,
+      {
+        length: text.length,
+        ...policy === "full" ? { text } : {}
+      },
+      options?.source ?? this.modelProviderSource(),
+      options?.correlationId,
+      options?.causationId
+    );
+  }
+  get mode() {
+    return this.currentMode;
+  }
+  get runId() {
+    return this.runIdValue;
+  }
+  subscribe(listener) {
+    return this.eventRecorder.subscribe(listener);
+  }
+  requestTurnHandoff() {
+    this.turnHandoffRequested = true;
+  }
+  storeRunDir() {
+    return this.storageCoordinator.runDir;
+  }
+  async ensureStoreInitialized() {
+    await this.storageCoordinator.ensureInitialized();
+    const stored = await this.storageCoordinator.loadRuntimeState();
+    if (stored) this.applyStoredRuntimeState(stored);
+  }
+  async ensureSandboxOpen() {
+    await this.sandboxManager.ensureOpen();
+  }
+  async closeSandbox() {
+    await this.sandboxManager.close();
+  }
+  async closeStore() {
+    await this.storageCoordinator.close();
+  }
+  applyStoredRuntimeState(stored) {
+    this.contextRegistry.loadSnapshots(stored.contextSnapshots);
+    for (const snapshot of stored.snapshots) {
+      this.snapshotManager.load(snapshot);
+      this.transcriptManager.addBranches(snapshot.branches);
+    }
+    this.transcriptManager.loadTranscript(stored.transcript);
+    this.metrics.messageCount = this.transcriptManager.count;
+    this.eventRecorder.load(stored.events);
+    this.metrics.eventCount = this.eventRecorder.count;
+    if (stored.cursors) {
+      this.transcriptManager.loadCursors({
+        ...stored.cursors,
+        eventExists: (eventId) => this.eventRecorder.has(eventId)
+      });
+    }
+  }
+  async persistCursors() {
+    await this.ensureStoreInitialized();
+    await this.storageCoordinator.saveCursors({
+      transcriptCursor: cloneJSON4(this.transcriptManager.activeTranscriptCursor),
+      eventCursor: cloneJSON4(this.transcriptManager.activeEventCursor),
+      branches: cloneJSON4(this.transcriptManager.allBranches)
+    });
+  }
+  async beginNewRun() {
+    if (this.started) {
+      await this.closeSandbox();
+      this.runIdValue = randomId();
+      await this.storageCoordinator.beginRun(this.runIdValue);
+      this.started = false;
+    }
+    this.startedAtPerf = 0;
+    this.metrics = emptyMetrics();
+    this.finalAnswer = "";
+    this.turnHandoffRequested = false;
+  }
+  async run(message, options = {}) {
+    if (options.signal?.aborted) throw new Error("Run aborted.");
+    await this.beginNewRun();
+    this.runModelOverride = void 0;
+    this.runModelOverride = this.normalizeModelOverride(options.model);
+    let runStarted = false;
+    try {
+      await this.start();
+      runStarted = true;
+      this.pendingInputs.push({
+        id: options.userInputId,
+        content: message,
+        metadata: options.userMetadata,
+        role: options.userRole,
+        external: true
+      });
+      const maxRunnerTurns = this.options.maxTurns ?? 5;
+      while (this.pendingInputs.length > 0 && this.metrics.turnCount < maxRunnerTurns) {
+        if (options.signal?.aborted) throw new Error("Run aborted.");
+        const input = this.pendingInputs.shift();
+        await this.runTurn(input, options);
+      }
+      const completedAt = nowIso4();
+      this.metrics.completedAt = completedAt;
+      this.metrics.durationMs = Math.round(performance.now() - this.startedAtPerf);
+      this.metrics.finalMode = this.currentMode;
+      await this.storageCoordinator.saveTranscript(this.transcriptManager.allMessages);
+      await this.emitInternal(RunEndEvent, {
+        metrics: cloneJSON4({ ...this.metrics, eventCount: this.eventRecorder.count + 1 }),
+        finalAnswer: this.finalAnswer
+      });
+      this.contextRegistry.expireScope("run" /* Run */);
+      this.metrics.durationMs = Math.round(performance.now() - this.startedAtPerf);
+      await this.storageCoordinator.saveMetrics(this.metrics);
+      this.log(RunCompletedLog, {
+        durationMs: this.metrics.durationMs,
+        messageCount: this.metrics.messageCount,
+        eventCount: this.metrics.eventCount
+      });
+      return {
+        runId: this.runId,
+        agentKey: this.agent.key,
+        finalAnswer: this.finalAnswer,
+        transcript: cloneJSON4(this.filterTranscript()),
+        events: this.queryEvents().map((event) => cloneJSON4(event.record)),
+        metrics: cloneJSON4(this.metrics),
+        outputDir: this.storeRunDir()
+      };
+    } catch (error) {
+      this.log(RunFailedLog, { error });
+      throw error;
+    } finally {
+      if (runStarted) await this.closeSandbox();
+      this.runModelOverride = void 0;
+    }
+  }
+  async prompt(message, options = {}) {
+    return this.run(message, options);
+  }
+  async close() {
+    await this.closeSandbox();
+    await this.closeStore();
+  }
+  getTranscript(options) {
+    return cloneJSON4(this.filterTranscript(options));
+  }
+  getMetrics() {
+    return cloneJSON4({
+      ...this.metrics,
+      durationMs: this.startedAtPerf > 0 ? Math.round(performance.now() - this.startedAtPerf) : 0,
+      finalMode: this.currentMode
+    });
+  }
+  getRunInfo() {
+    return {
+      runId: this.runId,
+      agentKey: this.agent.key,
+      workDir: this.workDir,
+      outputDir: this.storeRunDir(),
+      started: this.started,
+      startedAt: this.metrics.startedAt
+    };
+  }
+  getModel() {
+    return this.getActiveModel();
+  }
+  setModel(model) {
+    this.modelOverride = this.normalizeModelOverride(model);
+  }
+  clearModelOverride() {
+    this.modelOverride = void 0;
+  }
+  getModelProviderInfo() {
+    const resolved = this.resolveModelProvider(this.getActiveModel());
+    return resolved.provider.getInfo?.() ?? {
+      id: modelProviderId(resolved.provider),
+      provider: resolved.namespace
+    };
+  }
+  getAvailableModels() {
+    return this.providerRegistry.list().flatMap((provider) => {
+      const models = provider.getModels?.() ?? [];
+      return models.map((model) => ({
+        ...model,
+        id: model.id.includes("/") ? model.id : `${provider.namespace}/${model.id}`,
+        provider: model.provider ?? provider.namespace
+      }));
+    });
+  }
+  getAgentManifest() {
+    return {
+      key: this.agent.key,
+      label: this.agent.label,
+      initialMode: this.agent.initialMode,
+      currentMode: this.currentMode,
+      modes: Object.values(this.agent.modes).map((mode) => modeSummary(mode)),
+      roles: this.roles.map((role) => this.roleResolver.summary(role)),
+      hooks: (this.agent.hooks ?? []).map((hook) => this.hookSummary(hook)),
+      contextProviders: this.getContextProviders().map((provider) => contextProviderSummary(provider)),
+      tools: this.getAllTools().map((tool) => this.toToolCatalogEntry(tool)),
+      events: this.eventSummaries()
+    };
+  }
+  getEvents(filter) {
+    return this.queryEvents(filter).map((event) => cloneJSON4(event.record));
+  }
+  getTranscriptCursor() {
+    return cloneJSON4(this.transcriptManager.activeTranscriptCursor);
+  }
+  async seekTranscript(target) {
+    return this.applyTranscriptSeek(target);
+  }
+  async latestTranscript() {
+    return this.applyTranscriptSeek("latest");
+  }
+  getState() {
+    return cloneJSON4(this.state);
+  }
+  updateState(patch) {
+    if (patch && typeof patch === "object" && !Array.isArray(patch)) {
+      Object.assign(this.state, patch);
+    } else {
+      this.state.value = patch;
+    }
+  }
+  replaceState(next) {
+    this.state = cloneJSON4(next);
+  }
+  async createSnapshot(input, eventOptions) {
+    return this.snapshotManager.create(input, eventOptions);
+  }
+  listSnapshots() {
+    return this.snapshotManager.list();
+  }
+  getSnapshot(id) {
+    return this.snapshotManager.get(id);
+  }
+  async restoreSnapshot(id, eventOptions) {
+    return this.snapshotManager.restore(id, eventOptions);
+  }
+  async deleteSnapshot(id, eventOptions) {
+    return this.snapshotManager.deletePersisted(id, eventOptions);
+  }
+  getContextSnapshot() {
+    return this.contextRegistry.current ? cloneJSON4(this.contextRegistry.current) : void 0;
+  }
+  getContextEntries(filter) {
+    return cloneJSON4(this.contextRegistry.filter(filter));
+  }
+  async switchMode(mode, input) {
+    const modeId = this.resolveModeType(mode);
+    const previousModeId = this.currentMode;
+    const previous = this.getModeDefinition(previousModeId);
+    if (previousModeId !== modeId) {
+      await this.ensureSandboxOpen();
+      await previous.onExit?.(
+        this.buildActionSession(
+          void 0,
+          { kind: "mode", id: previousModeId, name: getConstructLabel(previous) }
+        ),
+        modeSummary(this.getModeDefinition(modeId))
+      );
+      this.currentMode = modeId;
+      const next = this.getModeDefinition(modeId);
+      await next.onEnter?.(
+        this.buildActionSession(
+          void 0,
+          { kind: "mode", id: modeId, name: getConstructLabel(next) }
+        ),
+        input
+      );
+      await this.emitInternal(ModeChangedEvent, {
+        previousMode: previousModeId,
+        mode: modeId,
+        input
+      });
+    }
+    if (input !== void 0) {
+      this.pendingInputs.push({
+        content: typeof input === "string" ? input : JSON.stringify(input, null, 2),
+        external: false
+      });
+    }
+  }
+  async start() {
+    if (this.started) return;
+    await this.ensureStoreInitialized();
+    await this.ensureSandboxOpen();
+    this.started = true;
+    this.startedAtPerf = performance.now();
+    this.log(RunStartedLog, { modeId: this.currentMode, model: this.getActiveModel() });
+    await this.emitInternal(RunStartEvent, {
+      agentKey: this.agent.key,
+      modeId: this.currentMode,
+      workDir: this.workDir,
+      outputDir: this.storeRunDir()
+    });
+  }
+  async runTurn(input, options) {
+    if (input.external !== false) {
+      await this.createSnapshot({
+        label: "Before user message",
+        metadata: {
+          kind: "before_user_message",
+          automatic: true,
+          userInputId: input.id
+        }
+      }, { hiddenTranscript: false });
+      this.transcriptManager.ensureBranchForAppend();
+    }
+    this.metrics.turnCount++;
+    this.currentTurnId = randomId();
+    const turnStart = performance.now();
+    this.log(TurnStartedLog, { turnId: this.currentTurnId });
+    await this.emitInternal(TurnStartEvent, { turnId: this.currentTurnId, input: input.content });
+    const inputRole = this.resolveRole(input.role ?? userRole);
+    await this.emitInternal(MessageStartEvent, { role: inputRole.role });
+    const userMessage = await this.addMessage(inputRole.role, input.content, input.metadata, inputRole, input.id);
+    await this.emitInternal(MessageEndEvent, { message: userMessage });
+    await this.markMessageEventCursor(userMessage.id);
+    const mode = this.getModeDefinition(this.currentMode);
+    const tools = await this.resolveTools();
+    await this.emitInternal(MessageStartEvent, { role: "assistant" });
+    try {
+      await this.modelPipeline.run({
+        mode,
+        userMessage,
+        tools,
+        options
+      });
+    } catch (error) {
+      if (error instanceof TurnHandoffSignal) return;
+      throw error;
+    } finally {
+      this.log(TurnCompletedLog, {
+        turnId: this.currentTurnId,
+        durationMs: Math.round(performance.now() - turnStart)
+      });
+      await this.emitInternal(TurnEndEvent, { turnId: this.currentTurnId, finalAnswer: this.finalAnswer });
+      this.contextRegistry.expireScope("turn" /* Turn */, this.currentTurnId);
+      this.currentTurnId = void 0;
+    }
+  }
+  async addMessage(role, content, metadata, roleInfo, id) {
+    const message = this.transcriptManager.appendMessage({
+      id,
+      role,
+      content,
+      modeId: this.currentMode,
+      turnId: this.currentTurnId,
+      metadata,
+      roleInfo
+    });
+    this.metrics.messageCount = this.transcriptManager.count;
+    await this.storageCoordinator.saveTranscript(this.transcriptManager.allMessages);
+    await this.persistCursors();
+    return message;
+  }
+  async addHiddenEventMessage(record) {
+    this.transcriptManager.appendMessage({
+      branchId: record.branchId,
+      role: "event",
+      content: record,
+      createdAt: record.at,
+      modeId: record.modeId,
+      turnId: record.turnId,
+      hidden: true,
+      metadata: { eventId: record.id, eventType: record.type }
+    });
+    this.metrics.messageCount = this.transcriptManager.count;
+    await this.storageCoordinator.saveTranscript(this.transcriptManager.allMessages);
+    await this.persistCursors();
+  }
+  async addToolCallMessage(tool, args, toolCallId, source) {
+    return this.addMessage("assistant", [{
+      type: "tool-call",
+      toolCallId,
+      toolName: tool.name,
+      input: args
+    }], {
+      toolCallId,
+      toolName: tool.name,
+      source
+    });
+  }
+  async addToolResultMessage(tool, result, toolCallId) {
+    await this.addMessage("tool", [{
+      type: "tool-result",
+      toolCallId,
+      toolName: tool.name,
+      output: result.data ?? result.content
+    }], {
+      toolCallId,
+      toolName: tool.name,
+      isError: result.isError,
+      ...result.metadata
+    });
+  }
+  async markMessageEventCursor(messageId) {
+    if (!this.transcriptManager.markMessageEventCursor(messageId)) return;
+    await this.storageCoordinator.saveTranscript(this.transcriptManager.allMessages);
+  }
+  createInitialState(agent) {
+    const initial = agent.sharedState?.initial;
+    if (typeof initial === "function") return cloneJSON4(initial());
+    if (initial && typeof initial === "object") return cloneJSON4(initial);
+    return {};
+  }
+  getModeDefinition(modeId) {
+    const mode = this.agent.modes[modeId];
+    if (!mode) throw new Error(`Unknown mode '${modeId}' for agent '${this.agent.key}'.`);
+    return mode;
+  }
+  resolveModeType(selector) {
+    for (const mode of Object.values(this.agent.modes)) {
+      if (modeMatchesSelector(mode, selector)) return getConstructType(mode);
+    }
+    throw new Error(`Unknown mode '${getConstructType(selector)}' for agent '${this.agent.key}'.`);
+  }
+  buildReadSession(source = { kind: "runtime" }, correlationId, causationId) {
+    const log = this.options.logger?.agent(this.logContext(source, correlationId, causationId)) ?? noopAgentLogSession;
+    return {
+      runId: this.runId,
+      turnId: this.currentTurnId,
+      agentKey: this.agent.key,
+      workDir: this.workDir,
+      outputDir: this.storeRunDir(),
+      services: this.services,
+      state: {
+        get: () => cloneJSON4(this.state)
+      },
+      history: {
+        get: (options) => this.getTranscript({ includeHidden: false, ...options })
+      },
+      events: {
+        query: (filter) => this.queryEvents(filter).map((event) => cloneJSON4(event.record))
+      },
+      mode: {
+        current: () => modeSummary(this.getModeDefinition(this.currentMode))
+      },
+      context: {
+        get: (filter) => this.getContextEntries(filter),
+        snapshot: () => this.getContextSnapshot()
+      },
+      log
+    };
+  }
+  buildActionSession(tool, source = tool ? { kind: "tool", id: tool.id, name: tool.name } : { kind: "runtime" }, correlationId, causationId) {
+    const readSession = this.buildReadSession(source, correlationId, causationId);
+    const sandbox = this.sandboxManager.current;
+    if (!sandbox) throw new Error("Sandbox session has not been opened.");
+    const applyEmitDefaults = (options) => this.withEmitDefaults(source, correlationId, causationId, options);
+    return {
+      ...readSession,
+      sandbox,
+      state: {
+        get: () => cloneJSON4(this.state),
+        update: (patch) => this.updateState(patch),
+        set: (next) => this.replaceState(next)
+      },
+      events: {
+        ...readSession.events,
+        emit: (eventClass, payload2, options) => this.emit(eventClass, payload2, applyEmitDefaults(options))
+      },
+      mode: {
+        ...readSession.mode,
+        switch: async (mode, input) => this.switchMode(mode, input)
+      },
+      tools: {
+        invoke: (tool2, args) => this.invokeTool(tool2, args, source, correlationId, causationId)
+      },
+      context: {
+        ...readSession.context,
+        add: (input, options) => Promise.resolve(this.addDynamicContext(input, options)),
+        render: (binding, options) => this.renderDynamicContext(binding, options),
+        remove: (id) => Promise.resolve(this.removeDynamicContext(id)),
+        clear: (filter) => Promise.resolve(this.clearDynamicContext(filter))
+      },
+      messages: {
+        enqueue: async (input, options) => {
+          const message = normalizeAgentMessageInput(input);
+          this.pendingInputs.push({
+            id: message.id,
+            content: message.content,
+            metadata: { ...message.metadata, ...options?.metadata },
+            role: message.role,
+            external: false
+          });
+        }
+      },
+      snapshots: {
+        create: (input) => this.createSnapshot(input, applyEmitDefaults({ hiddenTranscript: false }))
+      },
+      toolCall: tool
+    };
+  }
+  withEmitDefaults(source, correlationId, causationId, options) {
+    return {
+      ...options,
+      source: options?.source ?? source,
+      correlationId: options?.correlationId ?? correlationId,
+      causationId: options?.causationId ?? causationId
+    };
+  }
+  throwIfTurnHandoffRequested() {
+    if (!this.turnHandoffRequested) return;
+    this.turnHandoffRequested = false;
+    throw new TurnHandoffSignal();
+  }
+  normalizeModelOverride(model) {
+    if (model === void 0) return void 0;
+    const next = model.trim();
+    if (!next) throw new Error("Model must not be empty.");
+    this.resolveModelProvider(next);
+    return next;
+  }
+  getActiveModel() {
+    return this.runModelOverride ?? this.modelOverride ?? this.getModeDefinition(this.currentMode).model ?? this.defaultModel;
+  }
+  resolveModelProvider(model) {
+    return this.providerRegistry.resolve(model);
+  }
+  modelProviderSource() {
+    const resolved = this.resolveModelProvider(this.getActiveModel());
+    const id = modelProviderId(resolved.provider);
+    return { kind: "model_provider", id, name: id };
+  }
+  filterTranscript(options) {
+    return this.transcriptManager.filter(options, this.currentTurnId);
+  }
+  getActiveContextProviderBindings() {
+    const mode = this.getModeDefinition(this.currentMode);
+    if (!mode.providers) return [];
+    if (mode.providers === "all") {
+      return this.getContextProviders().filter((provider) => !mode.excludeProviders?.includes(getConstructType(provider))).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    return mode.providers.filter((binding) => !mode.excludeProviders?.includes(this.bindingToSummary(binding).type));
+  }
+  getContextProviders() {
+    const providers = /* @__PURE__ */ new Map();
+    for (const mode of Object.values(this.agent.modes)) {
+      if (!mode.providers || mode.providers === "all") continue;
+      for (const binding of mode.providers) {
+        const provider = this.providerFromReference(binding, false).provider;
+        providers.set(getConstructType(provider), provider);
+      }
+    }
+    return [...providers.values()];
+  }
+  providerFromReference(reference, allowClassSelector) {
+    if (!isContextProviderReference(reference)) {
+      throw new Error("Invalid context provider reference. Use a provider instance or provider.with(options).");
+    }
+    const selector = isContextProviderBinding(reference) ? reference.provider : reference;
+    const options = isContextProviderBinding(reference) ? reference.options : void 0;
+    if (isContextProviderInstance(selector)) {
+      assertNoAuthorId(selector, "Context provider");
+      return { provider: selector, options };
+    }
+    if (isContextProviderClass(selector)) {
+      if (!allowClassSelector) {
+        throw new Error(
+          `Context provider '${getConstructType(selector)}' is a class selector. Register an instance in mode.providers.`
+        );
+      }
+      const provider = this.getContextProviders().find((candidate) => contextProviderMatchesSelector(candidate, selector));
+      if (!provider) throw new Error(`Unknown context provider '${getConstructType(selector)}'.`);
+      return { provider, options };
+    }
+    throw new Error("Invalid context provider reference. Provider ids and strings are not supported.");
+  }
+  bindingToSummary(binding) {
+    const { provider, options } = this.providerFromReference(binding, true);
+    return contextProviderSummary(provider, options);
+  }
+  dynamicContextEntriesFor(eventClass) {
+    return this.contextRegistry.entriesFor(eventClass, this.runId, this.currentTurnId);
+  }
+  activateDynamicContextFor(eventClass, record) {
+    this.contextRegistry.activateFor(eventClass, record, this.runId, this.currentTurnId);
+  }
+  consumeDynamicContext(entries) {
+    this.contextRegistry.consume(entries);
+  }
+  addDynamicContext(input, options = {}, provider) {
+    const contribution = this.normalizeContextContribution(
+      input,
+      {
+        providerId: provider?.type,
+        providerLabel: provider?.label
+      }
+    );
+    return this.addDynamicContextContribution(contribution, options);
+  }
+  addDynamicContextContribution(contribution, options = {}) {
+    return this.contextRegistry.addContribution({
+      contribution,
+      options,
+      runId: this.runId,
+      turnId: this.currentTurnId,
+      modeId: this.currentMode
+    });
+  }
+  async renderDynamicContext(binding, options) {
+    const rendered = await this.loadContextProvider(binding);
+    return rendered.contributions.map((contribution, index) => this.addDynamicContextContribution(
+      contribution,
+      {
+        ...options,
+        id: options?.id && rendered.contributions.length === 1 ? options.id : options?.id ? `${options.id}:${index}` : void 0
+      }
+    ));
+  }
+  removeDynamicContext(id) {
+    return this.contextRegistry.remove(id);
+  }
+  clearDynamicContext(filter) {
+    return this.contextRegistry.clear(filter);
+  }
+  async buildContextSnapshot(trigger = ModelBeforeEvent) {
+    const started = performance.now();
+    const activeBindings = this.getActiveContextProviderBindings();
+    this.log(ContextBuildStartedLog, { providerCount: activeBindings.length }, { kind: "runtime" });
+    const providers = [];
+    for (const binding of activeBindings) {
+      providers.push(await this.loadContextProvider(binding));
+    }
+    const dynamicEntries = this.dynamicContextEntriesFor(trigger);
+    const contributions = [
+      ...providers.flatMap((provider) => provider.contributions),
+      ...dynamicEntries.map((entry) => entry.contribution)
+    ];
+    const systemContributions = contributions.filter((contribution) => this.resolveRole(contribution.role).target === "system" /* System */);
+    const messageContributions = contributions.filter((contribution) => this.resolveRole(contribution.role).target === "messages" /* Messages */);
+    const systemPrompt = this.renderSystemContributions(systemContributions);
+    const messages = messageContributions.map((contribution) => this.contributionToMessage(contribution));
+    const snapshot = {
+      id: randomId(),
+      turnId: this.currentTurnId,
+      modeId: this.currentMode,
+      createdAt: nowIso4(),
+      providers,
+      contributions,
+      systemPrompt,
+      messages
+    };
+    this.contextRegistry.recordSnapshot(snapshot);
+    await this.storageCoordinator.saveContextSnapshot(snapshot);
+    this.consumeDynamicContext(dynamicEntries);
+    this.log(ContextBuildCompletedLog, {
+      providerCount: providers.length,
+      contributionCount: contributions.length,
+      durationMs: Math.round(performance.now() - started)
+    }, { kind: "runtime" });
+    return snapshot;
+  }
+  async loadContextProvider(binding) {
+    const { provider, options } = this.providerFromReference(binding, true);
+    const summary = contextProviderSummary(provider, options);
+    if (this.providerStack.includes(summary.type)) {
+      throw new Error(`Context provider cycle detected: ${[...this.providerStack, summary.type].join(" -> ")}`);
+    }
+    this.providerStack.push(summary.type);
+    try {
+      const output = await provider.render(
+        this.buildReadSession(
+          { kind: "context_provider", id: summary.type, name: summary.label },
+          this.currentTurnId
+        ),
+        options
+      );
+      return {
+        providerId: summary.type,
+        providerLabel: summary.label,
+        binding: summary,
+        contributions: this.normalizeContextOutput(provider, output)
+      };
+    } catch (error) {
+      this.log(
+        ContextProviderFailedLog,
+        { providerType: summary.type, error },
+        { kind: "context_provider", id: summary.type, name: summary.label },
+        this.currentTurnId
+      );
+      throw error;
+    } finally {
+      this.providerStack.pop();
+    }
+  }
+  normalizeContextContribution(input, context = {}) {
+    if (typeof input === "string") {
+      const role2 = this.resolveRole(context.defaultRole ?? systemRole);
+      return {
+        providerId: context.providerId,
+        providerLabel: context.providerLabel,
+        role: role2.authorRole,
+        authorRole: role2.authorRole,
+        roleType: role2.roleType,
+        content: input
+      };
+    }
+    const role = this.resolveRole(input.role ?? context.defaultRole ?? systemRole);
+    return {
+      providerId: context.providerId,
+      providerLabel: context.providerLabel,
+      role: role.authorRole,
+      authorRole: role.authorRole,
+      roleType: role.roleType,
+      content: input.content,
+      metadata: input.metadata
+    };
+  }
+  normalizeContextOutput(provider, output) {
+    const summary = contextProviderSummary(provider);
+    if (output == null) return [];
+    const entries = Array.isArray(output) ? output : [output];
+    return entries.map((entry) => {
+      if (typeof entry === "string" && !entry.trim()) return void 0;
+      if (typeof entry !== "string" && (entry.content == null || typeof entry.content === "string" && !entry.content.trim())) {
+        return void 0;
+      }
+      return this.normalizeContextContribution(entry, {
+        providerId: summary.type,
+        providerLabel: summary.label,
+        defaultRole: provider.role
+      });
+    }).filter(Boolean);
+  }
+  resolveRole(selector) {
+    return this.roleResolver.resolve(selector);
+  }
+  assertModelProviderSupportsMessages(messages) {
+    this.roleResolver.assertModelProviderSupportsMessages(messages);
+  }
+  renderSystemContributions(contributions) {
+    if (!contributions.length) return "";
+    const rendered = contributions.map((contribution) => {
+      const label = contribution.providerLabel ?? contribution.providerId ?? contribution.role;
+      return `## ${label}
+
+${stringifyContent(contribution.content)}`;
+    });
+    return `# Runtime Context
+
+${rendered.join("\n\n")}`;
+  }
+  contributionToMessage(contribution) {
+    const role = this.resolveRole(contribution.role);
+    return {
+      id: randomId(),
+      seq: 0,
+      branchId: this.transcriptManager.activeTranscriptCursor.branchId,
+      role: role.role,
+      authorRole: contribution.authorRole ?? role.authorRole,
+      roleType: contribution.roleType ?? role.roleType,
+      content: contribution.content,
+      createdAt: nowIso4(),
+      modeId: this.currentMode,
+      turnId: this.currentTurnId,
+      eventCursor: cloneJSON4(this.transcriptManager.activeEventCursor),
+      metadata: {
+        contextProviderId: contribution.providerId,
+        contextRole: contribution.authorRole ?? contribution.role,
+        contextRoleType: contribution.roleType,
+        ...contribution.metadata
+      }
+    };
+  }
+  async resolveTools() {
+    const mode = this.getModeDefinition(this.currentMode);
+    const tools = [];
+    for (const source of mode.tools ?? []) {
+      if (!isToolInstance(source)) throw new Error("Mode tools must extend HarnessTool. Tool factories and object literals are not supported.");
+      assertNoAuthorId(source, "Tool");
+      tools.push(source);
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const tool of tools) {
+      if (names.has(tool.name)) throw new Error(`Duplicate toolName '${tool.name}' in mode '${this.currentMode}'.`);
+      names.add(tool.name);
+    }
+    return tools;
+  }
+  getAllTools() {
+    const tools = /* @__PURE__ */ new Map();
+    for (const mode of Object.values(this.agent.modes)) {
+      for (const source of mode.tools ?? []) {
+        if (!isToolInstance(source)) continue;
+        tools.set(source.name, source);
+      }
+    }
+    return [...tools.values()];
+  }
+  toToolCatalogEntry(tool) {
+    return {
+      name: tool.name,
+      description: tool.description,
+      risk: tool.risk,
+      permissions: tool.permissions,
+      requiresApproval: typeof tool.requiresApproval === "boolean" ? tool.requiresApproval : void 0
+    };
+  }
+  hookSummary(hook) {
+    const eventClass = hookEventClass(hook);
+    const type = eventType(eventClass);
+    return {
+      type: getConstructType(hook),
+      label: getConstructLabel(hook),
+      eventType: type,
+      eventClassId: type
+    };
+  }
+  eventSummaries() {
+    const summaries = /* @__PURE__ */ new Map();
+    const add = (eventClass, builtIn = false) => {
+      const type = eventType(eventClass);
+      summaries.set(type, {
+        type,
+        label: getConstructLabel(eventClass),
+        className: getConstructType(eventClass),
+        builtIn
+      });
+    };
+    for (const eventClass of runtimeEventClasses) add(eventClass, true);
+    for (const hook of this.agent.hooks ?? []) add(hookEventClass(hook));
+    for (const eventClass of this.agent.declaredEvents ?? []) add(eventClass);
+    return [...summaries.values()];
+  }
+  async invokeTool(selector, args, source = { kind: "runtime" }, parentCorrelationId, parentCausationId) {
+    const tool = (await this.resolveTools()).find((candidate) => toolMatchesSelector(candidate, selector));
+    if (!tool) {
+      const label = getConstructType(selector);
+      throw new Error(`Unknown tool '${label}' in mode '${this.currentMode}'.`);
+    }
+    return this.executeTool(tool, args, void 0, source, parentCorrelationId, parentCausationId);
+  }
+  async executeTool(tool, args, callId, source = { kind: "runtime" }, parentCorrelationId, parentCausationId) {
+    return this.toolExecutor.execute({
+      tool,
+      args,
+      callId,
+      source,
+      parentCorrelationId,
+      parentCausationId
+    });
+  }
+  async applyTranscriptSeek(target) {
+    const previousCursor = cloneJSON4(this.transcriptManager.activeTranscriptCursor);
+    const resolved = this.transcriptManager.resolveSeekTarget(target);
+    this.transcriptManager.applyResolvedSeek(resolved);
+    await this.emitInternal(TranscriptCursorChangedEvent, {
+      previousCursor,
+      cursor: this.transcriptManager.activeTranscriptCursor
+    }, { hiddenTranscript: false });
+    this.log(TranscriptCursorChangedLog, { cursorId: this.transcriptManager.activeTranscriptCursor.id });
+    this.transcriptManager.applyResolvedSeek(resolved);
+    await this.persistCursors();
+    return cloneJSON4(this.transcriptManager.activeTranscriptCursor);
+  }
+  async emitInternal(eventClass, payload2, options) {
+    return this.recordHarnessEvent(eventClass, payload2, {
+      source: { kind: "runtime" },
+      ...options
+    });
+  }
+  async emit(eventClass, payload2, options) {
+    return this.recordHarnessEvent(eventClass, payload2, options);
+  }
+  async recordHarnessEvent(eventClass, payload2, options) {
+    const type = eventType(eventClass);
+    const parsedPayload = normalizeSchema(eventClass.schema).parse(payload2);
+    if (type === MessageDeltaEvent.type) this.logModelDelta(parsedPayload, options);
+    this.transcriptManager.ensureBranchForEventAppend(
+      this.eventRecorder.latestForBranch(this.transcriptManager.activeEventCursor.branchId)
+    );
+    const branchId = this.transcriptManager.activeTranscriptCursor.branchId;
+    const event = this.eventRecorder.record({
+      eventClass,
+      branchId,
+      type,
+      source: options?.source ?? { kind: "custom" },
+      payload: parsedPayload,
+      runId: this.runId,
+      turnId: this.currentTurnId,
+      modeId: this.currentMode,
+      correlationId: options?.correlationId,
+      causationId: options?.causationId,
+      metadata: options?.metadata
+    });
+    const record = event.record;
+    this.transcriptManager.advanceEventCursor(record);
+    this.metrics.eventCount = this.eventRecorder.count;
+    await this.ensureStoreInitialized();
+    await this.storageCoordinator.recordEvent(record);
+    await this.persistCursors();
+    this.activateDynamicContextFor(eventClass, record);
+    if (options?.hiddenTranscript !== false) await this.addHiddenEventMessage(record);
+    await this.eventRecorder.notify(record);
+    if (!options?.skipHooks) await this.dispatchHooks(event);
+    return event;
+  }
+  queryEvents(filter) {
+    return this.eventRecorder.query(filter, this.transcriptManager.activeEventSegments());
+  }
+  async dispatchHooks(event) {
+    if (this.hookDepth > 25) throw new Error("Hook dispatch depth exceeded.");
+    const hooks = (this.agent.hooks ?? []).filter((hook) => {
+      const eventClass = hookEventClass(hook);
+      return eventClass ? eventType(eventClass) === event.type : false;
+    });
+    if (!hooks.length) return;
+    await this.ensureSandboxOpen();
+    this.hookDepth++;
+    try {
+      for (const hook of hooks) {
+        await hook.onActive(
+          this.buildActionSession(
+            void 0,
+            { kind: "hook", id: getConstructType(hook), name: getConstructLabel(hook) },
+            event.record.correlationId,
+            event.id
+          ),
+          event
+        );
+      }
+    } finally {
+      this.hookDepth--;
+    }
+  }
+};
+
+// src/session/types.ts
+var HarnessSessionPhase = /* @__PURE__ */ ((HarnessSessionPhase2) => {
+  HarnessSessionPhase2["Idle"] = "idle";
+  HarnessSessionPhase2["Queued"] = "queued";
+  HarnessSessionPhase2["Starting"] = "starting";
+  HarnessSessionPhase2["BuildingContext"] = "building_context";
+  HarnessSessionPhase2["WaitingModel"] = "waiting_model";
+  HarnessSessionPhase2["RunningTool"] = "running_tool";
+  HarnessSessionPhase2["WaitingApproval"] = "waiting_approval";
+  HarnessSessionPhase2["ClosingTurn"] = "closing_turn";
+  HarnessSessionPhase2["Completed"] = "completed";
+  HarnessSessionPhase2["Error"] = "error";
+  HarnessSessionPhase2["Closed"] = "closed";
+  return HarnessSessionPhase2;
+})(HarnessSessionPhase || {});
+
+// src/session/approvals.ts
+function nowIso5() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createToolApprovalHandle(input) {
+  const createdAt = nowIso5();
+  const expiresAt = input.timeoutMs > 0 ? new Date(Date.now() + input.timeoutMs).toISOString() : void 0;
+  const id = randomId();
+  return {
+    id,
+    sessionId: input.sessionId,
+    runId: input.runId,
+    toolCallId: input.request.id,
+    name: input.request.name,
+    args: input.request.args,
+    modeId: input.request.modeId,
+    risk: input.request.risk,
+    permissions: input.request.permissions,
+    createdAt,
+    expiresAt,
+    approve: () => input.approve(id),
+    deny: (reason) => input.deny(id, reason)
+  };
+}
+
+// src/session/approval-controller.ts
+var ApprovalController = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  pendingApprovals = /* @__PURE__ */ new Map();
+  approvalIdsByToolCallId = /* @__PURE__ */ new Map();
+  get count() {
+    return this.pendingApprovals.size;
+  }
+  getPending() {
+    return [...this.pendingApprovals.values()].map((approval) => approval.handle);
+  }
+  hydrateApprovalId(toolCallId) {
+    const approvalId = this.approvalIdsByToolCallId.get(toolCallId) ?? toolCallId;
+    this.approvalIdsByToolCallId.delete(toolCallId);
+    return approvalId;
+  }
+  request(request) {
+    return new Promise((resolve) => {
+      const handle = createToolApprovalHandle({
+        sessionId: this.input.sessionId,
+        runId: this.input.getRunId(),
+        request,
+        timeoutMs: this.input.timeoutMs,
+        approve: async (id) => this.resolve(id, true),
+        deny: async (id, reason) => this.resolve(id, false, reason)
+      });
+      const timeout = setTimeout(() => {
+        this.resolve(handle.id, false);
+      }, this.input.timeoutMs);
+      this.pendingApprovals.set(handle.id, {
+        handle,
+        timeout,
+        resolve: (approved) => resolve(approved ? "approved" : "denied")
+      });
+      this.approvalIdsByToolCallId.set(handle.toolCallId, handle.id);
+      this.input.notifyRequested(handle);
+    });
+  }
+  resolve(approvalId, approved, _reason) {
+    const pending = this.pendingApprovals.get(approvalId);
+    if (!pending) throw new Error(`Tool approval '${approvalId}' was not found.`);
+    if (pending.timeout) clearTimeout(pending.timeout);
+    this.pendingApprovals.delete(approvalId);
+    pending.resolve(approved);
+  }
+  denyAll() {
+    for (const approval of [...this.pendingApprovals.values()]) {
+      this.resolve(approval.handle.id, false);
+    }
+  }
+};
+
+// src/session/engine.ts
+async function resolveAgent(input) {
+  return input.definition;
+}
+function resolveWorkDir(workDir) {
+  return workDir ?? ".";
+}
+function resolveStorage(storage) {
+  return storage ?? new NoopRunStorage();
+}
+
+// src/session/event-hub.ts
+function payloadObject(record) {
+  return record.payload && typeof record.payload === "object" ? record.payload : {};
+}
+var SessionEventHub = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onEvent(eventClass, listener) {
+    const targetType = eventType(eventClass);
+    return this.on((event) => {
+      if (event.type !== "event" || event.event.type !== targetType) return;
+      void listener(new eventClass(event.event));
+    });
+  }
+  waitForEvent(eventClass, options = {}) {
+    return new Promise((resolve, reject) => {
+      let timeout;
+      const cleanup = this.onEvent(eventClass, (event) => {
+        if (timeout) clearTimeout(timeout);
+        cleanup();
+        resolve(event);
+      });
+      if (options.signal) {
+        if (options.signal.aborted) {
+          cleanup();
+          reject(options.signal.reason ?? new Error("waitForEvent aborted."));
+          return;
+        }
+        options.signal.addEventListener("abort", () => {
+          if (timeout) clearTimeout(timeout);
+          cleanup();
+          reject(options.signal?.reason ?? new Error("waitForEvent aborted."));
+        }, { once: true });
+      }
+      if (options.timeoutMs !== void 0) {
+        timeout = setTimeout(() => {
+          cleanup();
+          reject(new Error(`Timed out waiting for event '${eventType(eventClass)}'.`));
+        }, options.timeoutMs);
+      }
+    });
+  }
+  notify(event) {
+    for (const listener of this.listeners) void listener(event);
+  }
+  notifyRunnerRecord(record) {
+    for (const event of this.hydrateRuntimeRecord(record)) this.notify(event);
+  }
+  hydrateRuntimeRecord(record) {
+    const events = [];
+    const payload2 = payloadObject(record);
+    if (record.type === RunStartEvent.type) {
+      events.push({
+        type: "run.started",
+        sessionId: this.options.sessionId,
+        runId: record.runId,
+        mode: String(payload2.modeId ?? record.modeId ?? "")
+      });
+    } else if (record.type === MessageDeltaEvent.type) {
+      events.push({
+        type: "assistant.delta",
+        text: String(payload2.text ?? ""),
+        event: record
+      });
+    } else if (record.type === MessageEndEvent.type) {
+      const message = payload2.message;
+      if (message?.role === "user") events.push({ type: "user.message", message });
+      if (message?.role === "assistant") events.push({ type: "assistant.message", message });
+    } else if (record.type === ToolStartEvent.type) {
+      events.push({
+        type: "tool.started",
+        toolCallId: String(payload2.id ?? ""),
+        name: String(payload2.name ?? ""),
+        args: payload2.args
+      });
+    } else if (record.type === ToolApprovalResolvedEvent.type) {
+      const approvalId = String(payload2.id ?? "");
+      events.push({
+        type: "tool.approval.resolved",
+        approvalId: this.options.hydrateApprovalId?.(approvalId) ?? approvalId,
+        approved: payload2.decision === "approved"
+      });
+    } else if (record.type === ToolEndEvent.type) {
+      events.push({
+        type: "tool.ended",
+        toolCallId: String(payload2.id ?? ""),
+        name: String(payload2.name ?? ""),
+        result: payload2.result
+      });
+    } else if (record.type === ModeChangedEvent.type) {
+      events.push({
+        type: "mode.changed",
+        previousMode: String(payload2.previousMode ?? ""),
+        mode: String(payload2.mode ?? "")
+      });
+    }
+    events.push({ type: "event", event: record });
+    return events;
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/logging/logger.ts
+function normalizeModelDeltas(value) {
+  if (value === true) return "full";
+  if (value === false || value === void 0) return "none";
+  return value;
+}
+function configuredSinks(config) {
+  if (config.sinks?.length) return config.sinks;
+  if (config.level && config.level !== "silent") {
+    return [new ConsoleLogSink({ format: config.format ?? "pretty" })];
+  }
+  return [];
+}
+function messageFromUnknown(errorOrMessage) {
+  if (errorOrMessage instanceof Error) return errorOrMessage.message;
+  return String(errorOrMessage);
+}
+function payload(message, fields, error) {
+  return {
+    ...fields ?? {},
+    message,
+    ...error === void 0 ? {} : { error }
+  };
+}
+function createHarnessLogger(config = {}) {
+  const level = config.level ?? "silent";
+  const sinks = configuredSinks(config);
+  const modelDeltas = normalizeModelDeltas(config.modelDeltas);
+  const emit = (logClass, fields, context = {}) => {
+    const record = normalizeHarnessLog(logClass, fields, context, config.redact);
+    if (!shouldWriteLog(record.level, level)) return;
+    for (const sink of sinks) {
+      try {
+        void Promise.resolve(sink.write(record)).catch(() => void 0);
+      } catch {
+      }
+    }
+  };
+  const logger = {
+    modelDeltas,
+    emit,
+    debug(message, fields, context) {
+      emit(AgentDebugLog, payload(message, fields), context);
+    },
+    info(message, fields, context) {
+      emit(AgentInfoLog, payload(message, fields), context);
+    },
+    warn(message, fields, context) {
+      emit(AgentWarnLog, payload(message, fields), context);
+    },
+    error(errorOrMessage, fields, context) {
+      emit(AgentErrorLog, payload(messageFromUnknown(errorOrMessage), fields, errorOrMessage), context);
+    },
+    agent(context) {
+      return {
+        debug: (message, fields) => logger.debug(message, fields, context),
+        info: (message, fields) => logger.info(message, fields, context),
+        warn: (message, fields) => logger.warn(message, fields, context),
+        error: (errorOrMessage, fields) => logger.error(errorOrMessage, fields, context),
+        emit: (logClass, fields) => logger.emit(logClass, fields, context)
+      };
+    },
+    async flush() {
+      await Promise.all(sinks.map(async (sink) => {
+        try {
+          await sink.flush?.();
+        } catch {
+        }
+      }));
+    },
+    async close() {
+      await Promise.all(sinks.map(async (sink) => {
+        try {
+          await sink.close?.();
+        } catch {
+        }
+      }));
+    }
+  };
+  return logger;
+}
+
+// src/session/queue.ts
+var SessionQueue = class {
+  queue = Promise.resolve();
+  pendingSendTriggers = [];
+  enqueue(execute) {
+    const previous = this.queue;
+    const next = previous.then(execute, execute);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  addPendingSendTrigger(after) {
+    this.pendingSendTriggers.push(eventType(after ?? ToolEndEvent));
+  }
+  applyPendingSendTrigger(record) {
+    const targetType = this.pendingSendTriggers[0];
+    if (!targetType) return "none";
+    if (record.type === targetType) {
+      this.pendingSendTriggers.shift();
+      return record.type === RunEndEvent.type ? "cleared" : "handoff";
+    }
+    if (record.type === RunEndEvent.type) {
+      this.pendingSendTriggers.shift();
+      return "cleared";
+    }
+    return "none";
+  }
+};
+
+// src/session/stream.ts
+var AsyncEventQueue = class {
+  values = [];
+  waiters = [];
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter({ value, done: false });
+    else this.values.push(value);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) waiter({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const value = this.values.shift();
+        if (value) return Promise.resolve({ value, done: false });
+        if (this.closed) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve) => this.waiters.push(resolve));
+      }
+    };
+  }
+};
+function createHarnessRunStream(start, cancel) {
+  const queue = new AsyncEventQueue();
+  const controller = {
+    push: (event) => queue.push(event),
+    close: () => queue.close()
+  };
+  const result = start(controller).finally(() => queue.close());
+  return {
+    id: randomId(),
+    result,
+    cancel,
+    [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+  };
+}
+
+// src/session/status.ts
+function payloadObject2(record) {
+  return record.payload && typeof record.payload === "object" ? record.payload : {};
+}
+var SessionStatusTracker = class {
+  runningValue = false;
+  closedValue = false;
+  phaseValue = "idle" /* Idle */;
+  queuedInputCountValue = 0;
+  currentTurnIdValue;
+  activeToolValue;
+  lastEventAtValue;
+  lastErrorValue;
+  get running() {
+    return this.runningValue;
+  }
+  get queuedInputCount() {
+    return this.queuedInputCountValue;
+  }
+  get activeTool() {
+    return this.activeToolValue;
+  }
+  get phase() {
+    return this.closedValue ? "closed" /* Closed */ : this.phaseValue;
+  }
+  enqueueSend() {
+    this.queuedInputCountValue++;
+    if (this.runningValue) this.phaseValue = "queued" /* Queued */;
+  }
+  beginRun() {
+    this.runningValue = true;
+    this.queuedInputCountValue = Math.max(0, this.queuedInputCountValue - 1);
+    this.phaseValue = "starting" /* Starting */;
+  }
+  completeRun() {
+    this.phaseValue = "completed" /* Completed */;
+  }
+  failRun(error) {
+    this.lastErrorValue = error;
+    this.phaseValue = "error" /* Error */;
+  }
+  finishRun() {
+    this.runningValue = false;
+    if (!this.closedValue && this.phaseValue !== "error" /* Error */) {
+      this.phaseValue = this.queuedInputCountValue > 0 ? "queued" /* Queued */ : "idle" /* Idle */;
+    }
+  }
+  close() {
+    this.closedValue = true;
+    this.phaseValue = "closed" /* Closed */;
+  }
+  markClosingTurn() {
+    this.phaseValue = "closing_turn" /* ClosingTurn */;
+  }
+  applyRunnerRecord(record) {
+    this.lastEventAtValue = record.at;
+    const payload2 = payloadObject2(record);
+    if (record.type === RunStartEvent.type) {
+      this.phaseValue = "starting" /* Starting */;
+      this.currentTurnIdValue = void 0;
+      this.activeToolValue = void 0;
+      this.lastErrorValue = void 0;
+    } else if (record.type === ContextReadyEvent.type) {
+      this.phaseValue = "building_context" /* BuildingContext */;
+    } else if (record.type === ModelBeforeEvent.type) {
+      this.phaseValue = "waiting_model" /* WaitingModel */;
+    } else if (record.type === ToolStartEvent.type) {
+      this.phaseValue = "running_tool" /* RunningTool */;
+      this.activeToolValue = {
+        id: String(payload2.id ?? ""),
+        name: String(payload2.name ?? "")
+      };
+    } else if (record.type === ToolApprovalRequestedEvent.type) {
+      this.phaseValue = "waiting_approval" /* WaitingApproval */;
+    } else if (record.type === ToolEndEvent.type || record.type === ToolApprovalResolvedEvent.type) {
+      this.activeToolValue = void 0;
+      this.phaseValue = "waiting_model" /* WaitingModel */;
+    } else if (record.type === TurnEndEvent.type) {
+      this.phaseValue = "closing_turn" /* ClosingTurn */;
+      this.currentTurnIdValue = void 0;
+    } else if (record.type === RunEndEvent.type) {
+      this.phaseValue = "completed" /* Completed */;
+    } else if (record.type === ErrorEvent.type) {
+      this.phaseValue = "error" /* Error */;
+      this.lastErrorValue = { message: String(payload2.message ?? "Unknown error") };
+    }
+    if (record.turnId) this.currentTurnIdValue = record.turnId;
+  }
+  snapshot() {
+    return {
+      running: this.runningValue,
+      phase: this.phase,
+      queuedInputCount: this.queuedInputCountValue,
+      currentTurnId: this.currentTurnIdValue,
+      activeTool: this.activeToolValue,
+      lastEventAt: this.lastEventAtValue,
+      lastError: this.lastErrorValue
+    };
+  }
+};
+
+// src/session/session.ts
+var defaultApprovalTimeoutMs = 5 * 60 * 1e3;
+function nowIso6() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeInput(input) {
+  return typeof input === "string" ? { content: input } : input;
+}
+function resolveInitialMode(agent, mode) {
+  if (mode === void 0) return void 0;
+  if (typeof mode !== "string") return mode;
+  if (!Array.isArray(agent.modes)) return void 0;
+  const resolved = agent.modes.find((candidate) => getConstructType(candidate) === mode);
+  if (!resolved) throw new Error(`Unknown initial mode '${mode}'.`);
+  return resolved;
+}
+function toErrorShape(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      cause: error.cause
+    };
+  }
+  return { message: String(error) };
+}
+var HarnessSessionImpl = class {
+  constructor(config, input) {
+    this.config = config;
+    this.id = input.sessionId ?? randomId();
+    this.events = new SessionEventHub({
+      sessionId: this.id,
+      hydrateApprovalId: (toolCallId) => this.approvals.hydrateApprovalId(toolCallId)
+    });
+    this.logger = createHarnessLogger(config.logging);
+    this.approvals = new ApprovalController({
+      sessionId: this.id,
+      getRunId: () => this.runner.runId,
+      timeoutMs: this.config.toolApprovalTimeoutMs ?? defaultApprovalTimeoutMs,
+      notifyRequested: (approval) => this.notify({ type: "tool.approval.requested", approval })
+    });
+    const storage = resolveStorage(config.storage);
+    this.runner = new AgentSessionRunner({
+      sessionId: this.id,
+      agent: input.agent,
+      providers: config.providers,
+      defaultModel: config.defaultModel,
+      sandbox: config.sandbox,
+      workDir: input.workDir,
+      storage,
+      initialMode: resolveInitialMode(input.agent, config.initialMode),
+      toolApproval: config.toolApproval,
+      maxTurns: config.maxTurns,
+      services: config.services,
+      approveTool: (request) => this.requestToolApproval(request),
+      logger: this.logger
+    });
+    this.logger.emit(SessionCreatedLog, { sessionId: this.id }, { sessionId: this.id, source: { kind: "runtime" } });
+    this.unsubscribeRunner = this.runner.subscribe((record) => {
+      this.status.applyRunnerRecord(record);
+      this.applyPendingSendTrigger(record);
+      this.events.notifyRunnerRecord(record);
+      this.notifyStatus();
+    });
+    this.transcript = {
+      get: (options) => this.runner.getTranscript(options),
+      getCursor: () => this.runner.getTranscriptCursor(),
+      seek: (target) => this.runner.seekTranscript(target),
+      latest: () => this.runner.latestTranscript()
+    };
+    this.snapshots = {
+      create: (input2) => this.runner.createSnapshot(input2, { hiddenTranscript: false }),
+      list: () => this.runner.listSnapshots(),
+      get: (id) => this.runner.getSnapshot(id),
+      restore: (id) => {
+        this.assertSnapshotRestoreAllowed();
+        return this.runner.restoreSnapshot(id, { hiddenTranscript: false });
+      },
+      delete: (id) => this.runner.deleteSnapshot(id, { hiddenTranscript: false })
+    };
+  }
+  config;
+  id;
+  transcript;
+  snapshots;
+  runner;
+  events;
+  approvals;
+  queue = new SessionQueue();
+  status = new SessionStatusTracker();
+  createdAt = nowIso6();
+  logger;
+  lastActiveAt = this.createdAt;
+  closed = false;
+  activeAbort;
+  lastResult;
+  unsubscribeRunner;
+  async send(input, options) {
+    const stream = this.stream(input, options);
+    for await (const _event of stream) {
+    }
+    return stream.result;
+  }
+  stream(input, options = {}) {
+    const userInput = normalizeInput(input);
+    const externalSignal = options.signal;
+    const controller = new AbortController();
+    if (externalSignal) {
+      if (externalSignal.aborted) controller.abort(externalSignal.reason);
+      else externalSignal.addEventListener("abort", () => controller.abort(externalSignal.reason), { once: true });
+    }
+    this.status.enqueueSend();
+    if (this.status.running) this.queue.addPendingSendTrigger(options.after);
+    this.notifyStatus();
+    const run = async (streamController) => {
+      const execute = async () => {
+        if (this.closed) throw new Error(`Harness session '${this.id}' is closed.`);
+        const unsubscribe = this.on((event) => streamController.push(event));
+        this.status.beginRun();
+        this.activeAbort = controller;
+        this.lastActiveAt = nowIso6();
+        this.notifyStatus();
+        try {
+          const result = await this.runner.run(userInput.content, {
+            signal: controller.signal,
+            model: options.model,
+            userInputId: userInput.id,
+            userMetadata: userInput.metadata,
+            userRole: userInput.role
+          });
+          const sendResult = {
+            sessionId: this.id,
+            runId: result.runId,
+            agentKey: result.agentKey,
+            answer: result.finalAnswer,
+            mode: this.runner.mode,
+            outputDir: result.outputDir,
+            metrics: result.metrics,
+            transcript: result.transcript,
+            events: result.events
+          };
+          this.lastResult = sendResult;
+          this.status.completeRun();
+          this.notify({ type: "run.completed", result: sendResult });
+          this.notifyStatus();
+          await this.logger.flush();
+          return sendResult;
+        } catch (error) {
+          const shaped = toErrorShape(error);
+          this.status.failRun(shaped);
+          this.notify({ type: "error", error: shaped });
+          this.notifyStatus();
+          await this.logger.flush();
+          throw error;
+        } finally {
+          unsubscribe();
+          this.status.finishRun();
+          if (this.activeAbort === controller) this.activeAbort = void 0;
+          this.lastActiveAt = nowIso6();
+          this.notifyStatus();
+        }
+      };
+      return this.queue.enqueue(execute);
+    };
+    return createHarnessRunStream(run, async (reason) => {
+      controller.abort(reason);
+      await this.cancelActiveRun(reason);
+    });
+  }
+  getStatus() {
+    const runInfo = this.runner.getRunInfo();
+    const status = this.status.snapshot();
+    return {
+      sessionId: this.id,
+      agentKey: this.runner.agent.key,
+      mode: this.runner.mode,
+      model: this.runner.getModel(),
+      provider: this.runner.getModelProviderInfo(),
+      createdAt: this.createdAt,
+      lastActiveAt: this.lastActiveAt,
+      running: status.running,
+      phase: status.phase,
+      queuedInputCount: status.queuedInputCount,
+      currentTurnId: status.currentTurnId,
+      activeTool: status.activeTool,
+      lastEventAt: status.lastEventAt,
+      lastError: status.lastError,
+      pendingApprovalCount: this.approvals.count,
+      runId: runInfo.runId,
+      outputDir: this.lastResult?.outputDir ?? runInfo.outputDir,
+      metrics: this.lastResult?.metrics ?? this.runner.getMetrics()
+    };
+  }
+  getMode() {
+    return this.runner.mode;
+  }
+  getModel() {
+    return this.runner.getModel();
+  }
+  setModel(model) {
+    this.runner.setModel(model);
+    this.lastActiveAt = nowIso6();
+    this.notifyStatus();
+  }
+  clearModelOverride() {
+    this.runner.clearModelOverride();
+    this.lastActiveAt = nowIso6();
+    this.notifyStatus();
+  }
+  async switchMode(mode, input) {
+    await this.runner.switchMode(this.resolveModeSelector(mode), input);
+    this.lastActiveAt = nowIso6();
+  }
+  getState() {
+    return this.runner.getState();
+  }
+  updateState(patch) {
+    this.runner.updateState(patch);
+    this.lastActiveAt = nowIso6();
+  }
+  replaceState(next) {
+    this.runner.replaceState(next);
+    this.lastActiveAt = nowIso6();
+  }
+  getEvents(filter) {
+    return this.runner.getEvents(filter);
+  }
+  getContextSnapshot() {
+    return this.runner.getContextSnapshot();
+  }
+  getAgentManifest() {
+    return this.runner.getAgentManifest();
+  }
+  getPendingApprovals() {
+    return this.approvals.getPending();
+  }
+  async approveTool(approvalId) {
+    this.approvals.resolve(approvalId, true);
+  }
+  async denyTool(approvalId, _reason) {
+    this.approvals.resolve(approvalId, false);
+  }
+  on(listener) {
+    return this.events.on(listener);
+  }
+  onEvent(eventClass, listener) {
+    return this.events.onEvent(eventClass, listener);
+  }
+  waitForEvent(eventClass, options = {}) {
+    return this.events.waitForEvent(eventClass, options);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.status.close();
+    await this.cancelActiveRun("Session closed.");
+    this.unsubscribeRunner();
+    await this.runner.close();
+    this.notifyStatus();
+    this.events.clear();
+    await this.logger.close();
+  }
+  notify(event) {
+    this.events.notify(event);
+  }
+  notifyStatus() {
+    this.notify({ type: "session.status", status: this.getStatus() });
+  }
+  assertSnapshotRestoreAllowed() {
+    const reject = (reason) => {
+      this.logger.emit(
+        SnapshotRestoreRejectedLog,
+        { reason },
+        { sessionId: this.id, runId: this.runner.runId, source: { kind: "runtime" } }
+      );
+      throw new Error(reason);
+    };
+    if (this.closed) reject(`Harness session '${this.id}' is closed.`);
+    if (this.status.running || this.status.queuedInputCount > 0 || this.approvals.count > 0 || this.status.activeTool) {
+      reject("Snapshots can only be restored while the session is idle and has no pending approvals.");
+    }
+    if (this.status.phase !== "idle" /* Idle */) {
+      reject("Snapshots can only be restored while the session is idle and has no pending approvals.");
+    }
+  }
+  applyPendingSendTrigger(record) {
+    if (this.queue.applyPendingSendTrigger(record) === "handoff") {
+      this.status.markClosingTurn();
+      this.runner.requestTurnHandoff();
+    }
+  }
+  resolveModeSelector(mode) {
+    if (typeof mode !== "string") return mode;
+    const resolved = Object.values(this.runner.agent.modes).find((candidate) => getConstructType(candidate) === mode);
+    if (!resolved) throw new Error(`Unknown mode '${mode}'.`);
+    return resolved;
+  }
+  requestToolApproval(request) {
+    return this.approvals.request(request);
+  }
+  async cancelActiveRun(reason) {
+    this.activeAbort?.abort(reason);
+    this.approvals.denyAll();
+  }
+};
+async function createHarnessSession(config, options = {}) {
+  const workDir = resolveWorkDir(config.workDir);
+  const agent = await resolveAgent(config.agent);
+  return new HarnessSessionImpl(config, {
+    sessionId: options.sessionId,
+    agent,
+    workDir
+  });
+}
+
+// src/session/store.ts
+function mergeConfig(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    agent: overrides?.agent ?? base.agent,
+    providers: overrides?.providers ?? base.providers,
+    services: overrides?.services ?? base.services,
+    logging: overrides?.logging ?? base.logging
+  };
+}
+var HarnessSessionStoreImpl = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  unsubscriptions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  closed = false;
+  async getOrCreate(sessionId, overrides) {
+    this.cleanupExpired();
+    if (this.closed) throw new Error("Harness session store is closed.");
+    const id = sessionId?.trim() || randomId();
+    const existing = this.sessions.get(id);
+    if (existing) return existing;
+    const session = await createHarnessSession(mergeConfig(this.config, overrides), { sessionId: id });
+    this.sessions.set(id, session);
+    this.unsubscriptions.set(id, session.on((event) => this.notify({ type: "session.event", sessionId: id, event })));
+    this.notify({ type: "session.created", sessionId: id, status: session.getStatus() });
+    return session;
+  }
+  get(sessionId) {
+    this.cleanupExpired();
+    return this.sessions.get(sessionId);
+  }
+  list() {
+    this.cleanupExpired();
+    return [...this.sessions.values()].map((session) => session.getStatus());
+  }
+  async delete(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    this.sessions.delete(sessionId);
+    this.unsubscriptions.get(sessionId)?.();
+    this.unsubscriptions.delete(sessionId);
+    await session.close();
+    this.notify({ type: "session.deleted", sessionId });
+    return true;
+  }
+  async clear() {
+    for (const sessionId of [...this.sessions.keys()]) await this.delete(sessionId);
+    this.notify({ type: "session.cleared" });
+  }
+  async send(sessionId, input, options) {
+    const session = await this.getOrCreate(sessionId);
+    return session.send(input, options);
+  }
+  async stream(sessionId, input, options) {
+    const session = await this.getOrCreate(sessionId);
+    return session.stream(input, options);
+  }
+  getPendingApprovals(sessionId) {
+    if (sessionId) return this.sessions.get(sessionId)?.getPendingApprovals() ?? [];
+    return [...this.sessions.values()].flatMap((session) => session.getPendingApprovals());
+  }
+  async approveTool(sessionId, approvalId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Harness session '${sessionId}' was not found.`);
+    await session.approveTool(approvalId);
+  }
+  async denyTool(sessionId, approvalId, reason) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Harness session '${sessionId}' was not found.`);
+    await session.denyTool(approvalId, reason);
+  }
+  getAgentManifest(sessionId) {
+    return this.sessions.get(sessionId)?.getAgentManifest();
+  }
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    await this.clear();
+    this.listeners.clear();
+  }
+  notify(event) {
+    for (const listener of this.listeners) void listener(event);
+  }
+  cleanupExpired() {
+    const ttl = this.config.sessionTtlMs;
+    if (!ttl || ttl <= 0) return;
+    const cutoff = Date.now() - ttl;
+    for (const session of [...this.sessions.values()]) {
+      if (Date.parse(session.getStatus().lastActiveAt) < cutoff) void this.delete(session.id);
+    }
+  }
+};
+async function createHarnessSessionStore(config) {
+  return new HarnessSessionStoreImpl(config);
+}
+
+export {
+  createToolErrorPayload,
+  AgentSessionRunner,
+  HarnessSessionPhase,
+  HarnessSessionImpl,
+  createHarnessSession,
+  HarnessSessionStoreImpl,
+  createHarnessSessionStore
+};
+//# sourceMappingURL=chunk-4WWSQAWA.js.map