@ai-agent-forge/agent-forge 0.85.0

package/dist/core/extensions/lifecycle-catalog.js

@@ -0,0 +1,1903 @@
+export const PLUGIN_DISPOSE_EVENT_ID = "plugin.dispose";
+export const PLUGIN_DISPOSE_EVENT_VERSION = 1;
+export const PLUGIN_READY_EVENT_ID = "plugin.ready";
+export const PLUGIN_READY_EVENT_VERSION = 1;
+export const SESSION_CONTEXT_REPLACED_EVENT_ID = "session.context.replaced";
+export const SESSION_CONTEXT_REPLACED_EVENT_VERSION = 1;
+export const SESSION_RELOAD_EVENT_ID = "session.reload";
+export const SESSION_RELOAD_EVENT_VERSION = 1;
+export const AGENT_START_EVENT_ID = "agent.start";
+export const AGENT_START_EVENT_VERSION = 1;
+export const AGENT_SETTLED_EVENT_ID = "agent.settled";
+export const AGENT_SETTLED_EVENT_VERSION = 1;
+export const TURN_START_EVENT_ID = "turn.start";
+export const TURN_START_EVENT_VERSION = 1;
+export const TURN_END_EVENT_ID = "turn.end";
+export const TURN_END_EVENT_VERSION = 1;
+export const MESSAGE_START_EVENT_ID = "message.start";
+export const MESSAGE_START_EVENT_VERSION = 1;
+export const MESSAGE_END_EVENT_ID = "message.end";
+export const MESSAGE_END_EVENT_VERSION = 1;
+export const TOOL_EXECUTION_START_EVENT_ID = "tool.execution.start";
+export const TOOL_EXECUTION_START_EVENT_VERSION = 1;
+export const MODEL_SELECT_EVENT_ID = "model.select";
+export const MODEL_SELECT_EVENT_VERSION = 1;
+export const THINKING_LEVEL_SELECT_EVENT_ID = "thinking_level.select";
+export const THINKING_LEVEL_SELECT_EVENT_VERSION = 1;
+export const SESSION_INFO_CHANGED_EVENT_ID = "session.info.changed";
+export const SESSION_INFO_CHANGED_EVENT_VERSION = 1;
+export const SESSION_ENTRY_APPENDED_EVENT_ID = "session.entry.appended";
+export const SESSION_ENTRY_APPENDED_EVENT_VERSION = 1;
+export const AGENT_END_EVENT_ID = "agent.end";
+export const AGENT_END_EVENT_VERSION = 1;
+export const BEFORE_AGENT_START_EVENT_ID = "before.agent.start";
+export const BEFORE_AGENT_START_EVENT_VERSION = 1;
+export const BEFORE_AGENT_START_EVENT_VERSION_V2 = 2;
+export const UI_PROMPT_START_EVENT_ID = "ui.prompt.start";
+export const UI_PROMPT_START_EVENT_VERSION = 1;
+export const UI_PROMPT_END_EVENT_ID = "ui.prompt.end";
+export const UI_PROMPT_END_EVENT_VERSION = 1;
+export const RESOURCES_DISCOVER_EVENT_ID = "resources.discover";
+export const RESOURCES_DISCOVER_EVENT_VERSION = 1;
+export const RESOURCES_DISCOVER_EVENT_VERSION_V2 = 2;
+export const CONTEXT_ASSEMBLED_EVENT_ID = "context.assembled";
+export const CONTEXT_ASSEMBLED_EVENT_VERSION = 1;
+export const INPUT_RECEIVED_EVENT_ID = "input.received";
+export const INPUT_RECEIVED_EVENT_VERSION = 1;
+export const USER_BASH_EVENT_ID = "user.bash";
+export const USER_BASH_EVENT_VERSION = 1;
+export const SESSION_START_EVENT_ID = "session.start";
+export const SESSION_START_EVENT_VERSION = 1;
+export const MODEL_RESPONSE_EVENT_ID = "model.response";
+export const MODEL_RESPONSE_EVENT_VERSION = 1;
+export const MODEL_STREAM_EVENT_ID = "model.stream";
+export const MODEL_STREAM_EVENT_VERSION = 1;
+export const TOOL_RESULT_EVENT_ID = "tool.result";
+export const TOOL_RESULT_EVENT_VERSION = 1;
+export const TOOL_CALL_EVENT_ID = "tool.call";
+export const TOOL_CALL_EVENT_VERSION = 1;
+export const TOOL_RESULT_RAW_EVENT_ID = "tool.result.raw";
+export const TOOL_RESULT_RAW_EVENT_VERSION = 1;
+export const TOOL_EXECUTE_EVENT_ID = "tool.execute";
+export const TOOL_EXECUTE_EVENT_VERSION = 1;
+export const TOOL_COMMIT_EVENT_ID = "tool.commit";
+export const TOOL_COMMIT_EVENT_VERSION = 1;
+export const TOOL_GATE_BLOCKED_EVENT_ID = "tool.gate.blocked";
+export const TOOL_GATE_BLOCKED_EVENT_VERSION = 1;
+export const INPUT_GATE_BLOCKED_EVENT_ID = "input.gate.blocked";
+export const INPUT_GATE_BLOCKED_EVENT_VERSION = 1;
+export const OPERATION_END_EVENT_ID = "operation.end";
+export const OPERATION_END_EVENT_VERSION = 1;
+function assertString(value, label) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${label} must be a non-empty string`);
+}
+function assertJsonSafe(value, label, seen = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return;
+        throw new Error(`${label} must contain only finite JSON numbers`);
+    }
+    if (typeof value !== "object")
+        throw new Error(`${label} must be JSON-safe`);
+    if (seen.has(value))
+        throw new Error(`${label} must not contain cycles`);
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const [index, entry] of value.entries())
+            assertJsonSafe(entry, `${label}[${index}]`, seen);
+    }
+    else if (isPlainRecord(value)) {
+        for (const [key, entry] of Object.entries(value))
+            assertJsonSafe(entry, `${label}.${key}`, seen);
+    }
+    else {
+        throw new Error(`${label} must contain only JSON arrays and plain objects`);
+    }
+    seen.delete(value);
+}
+export function validatePluginDisposeEventDataV1(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error("plugin.dispose data must be a plain object");
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    if (keys.join(",") !== "pluginId,pluginVersion,status,version") {
+        throw new Error("plugin.dispose data has unsupported fields");
+    }
+    if (record.version !== 1)
+        throw new Error("plugin.dispose data.version must be 1");
+    assertString(record.pluginId, "plugin.dispose data.pluginId");
+    assertString(record.pluginVersion, "plugin.dispose data.pluginVersion");
+    if (record.status !== "disposed" && record.status !== "failed") {
+        throw new Error("plugin.dispose data.status is invalid");
+    }
+    return value;
+}
+export function pluginDisposeEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PLUGIN_DISPOSE_EVENT_ID,
+        version: PLUGIN_DISPOSE_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/plugin.dispose@1",
+        allowedRegistrationKinds,
+        validate: validatePluginDisposeEventDataV1,
+    };
+}
+export function validatePluginReadyEventDataV1(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error("plugin.ready data must be a plain object");
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    if (keys.join(",") !== "pluginId,pluginVersion,version") {
+        throw new Error("plugin.ready data has unsupported fields");
+    }
+    if (record.version !== 1)
+        throw new Error("plugin.ready data.version must be 1");
+    assertString(record.pluginId, "plugin.ready data.pluginId");
+    assertString(record.pluginVersion, "plugin.ready data.pluginVersion");
+    return value;
+}
+export function pluginReadyEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PLUGIN_READY_EVENT_ID,
+        version: PLUGIN_READY_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/plugin.ready@1",
+        allowedRegistrationKinds,
+        validate: validatePluginReadyEventDataV1,
+    };
+}
+export const PLUGIN_REJECTED_EVENT_ID = "plugin.rejected";
+export const PLUGIN_REJECTED_EVENT_VERSION = 1;
+export function validatePluginRejectedEventDataV1(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error("plugin.rejected data must be a plain object");
+    }
+    const record = value;
+    const keys = Object.keys(record)
+        .filter((key) => key !== "pluginId")
+        .sort();
+    if (keys.join(",") !== "code,manifestPath,message,version") {
+        throw new Error("plugin.rejected data has unsupported fields");
+    }
+    if (record.version !== 1)
+        throw new Error("plugin.rejected data.version must be 1");
+    if (record.pluginId !== undefined && typeof record.pluginId !== "string") {
+        throw new Error("plugin.rejected data.pluginId must be a string when present");
+    }
+    assertString(record.manifestPath, "plugin.rejected data.manifestPath");
+    assertString(record.message, "plugin.rejected data.message");
+    if (record.code !== "invalid_manifest" &&
+        record.code !== "duplicate_plugin_id" &&
+        record.code !== "missing_dependency" &&
+        record.code !== "plugin_load_failed") {
+        throw new Error("plugin.rejected data.code is invalid");
+    }
+    return value;
+}
+export function pluginRejectedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PLUGIN_REJECTED_EVENT_ID,
+        version: PLUGIN_REJECTED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/plugin.rejected@1",
+        allowedRegistrationKinds,
+        validate: validatePluginRejectedEventDataV1,
+    };
+}
+const contextReasons = new Set([
+    "request",
+    "reload",
+    "session_replace",
+    "compaction",
+    "overflow_recovery",
+    "retry",
+    "tree",
+]);
+export function validateSessionContextReplacedEventDataV1(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error("session.context.replaced data must be a plain object");
+    }
+    const record = value;
+    const allowed = new Set(["version", "sessionId", "reason", "messageCount", "strategyName"]);
+    const unsupported = Object.keys(record).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`session.context.replaced data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "reason", "messageCount"]) {
+        if (!(key in record))
+            throw new Error(`session.context.replaced data is missing required field: ${key}`);
+    }
+    if (record.version !== 1)
+        throw new Error("session.context.replaced data.version must be 1");
+    assertString(record.sessionId, "session.context.replaced data.sessionId");
+    if (typeof record.reason !== "string" ||
+        !contextReasons.has(record.reason)) {
+        throw new Error("session.context.replaced data.reason is invalid");
+    }
+    if (typeof record.messageCount !== "number" ||
+        !Number.isSafeInteger(record.messageCount) ||
+        record.messageCount < 0) {
+        throw new Error("session.context.replaced data.messageCount must be a non-negative safe integer");
+    }
+    if (record.strategyName !== undefined) {
+        assertString(record.strategyName, "session.context.replaced data.strategyName");
+    }
+    return value;
+}
+export function sessionContextReplacedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_CONTEXT_REPLACED_EVENT_ID,
+        version: SESSION_CONTEXT_REPLACED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.context.replaced@1",
+        allowedRegistrationKinds,
+        validate: validateSessionContextReplacedEventDataV1,
+    };
+}
+export function validateSessionReloadEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.reload data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "generation,reason,sessionId,version") {
+        throw new Error("session.reload data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("session.reload data.version must be 1");
+    assertString(value.sessionId, "session.reload data.sessionId");
+    if (typeof value.generation !== "number" || !Number.isSafeInteger(value.generation) || value.generation < 1) {
+        throw new Error("session.reload data.generation must be a positive safe integer");
+    }
+    if (value.reason !== "reload")
+        throw new Error("session.reload data.reason is invalid");
+    return value;
+}
+export function sessionReloadEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_RELOAD_EVENT_ID,
+        version: SESSION_RELOAD_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.reload@1",
+        allowedRegistrationKinds,
+        validate: validateSessionReloadEventDataV1,
+    };
+}
+export function validateAgentLifecycleEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("agent lifecycle data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,version") {
+        throw new Error("agent lifecycle data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("agent lifecycle data.version must be 1");
+    assertString(value.sessionId, "agent lifecycle data.sessionId");
+    return value;
+}
+export function agentStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: AGENT_START_EVENT_ID,
+        version: AGENT_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/agent.start@1",
+        allowedRegistrationKinds,
+        validate: validateAgentLifecycleEventDataV1,
+    };
+}
+export function agentSettledEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: AGENT_SETTLED_EVENT_ID,
+        version: AGENT_SETTLED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/agent.settled@1",
+        allowedRegistrationKinds,
+        validate: validateAgentLifecycleEventDataV1,
+    };
+}
+export function validateTurnStartEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("turn.start data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,turnIndex,version") {
+        throw new Error("turn.start data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("turn.start data.version must be 1");
+    assertString(value.sessionId, "turn.start data.sessionId");
+    if (typeof value.turnIndex !== "number" || !Number.isSafeInteger(value.turnIndex) || value.turnIndex < 0) {
+        throw new Error("turn.start data.turnIndex must be a non-negative safe integer");
+    }
+    return value;
+}
+export function validateTurnEndEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("turn.end data must be a plain object");
+    const keys = Object.keys(value).sort().join(",");
+    if (keys !== "messageCount,sessionId,turnIndex,version" &&
+        keys !== "messageCount,outcome,sessionId,turnIndex,version") {
+        throw new Error("turn.end data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("turn.end data.version must be 1");
+    assertString(value.sessionId, "turn.end data.sessionId");
+    if (typeof value.turnIndex !== "number" || !Number.isSafeInteger(value.turnIndex) || value.turnIndex < 0) {
+        throw new Error("turn.end data.turnIndex must be a non-negative safe integer");
+    }
+    if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
+        throw new Error("turn.end data.messageCount must be a non-negative safe integer");
+    }
+    if (value.outcome !== undefined && value.outcome !== "aborted" && value.outcome !== "error") {
+        throw new Error("turn.end data.outcome is invalid");
+    }
+    return value;
+}
+export function validateMessageBoundaryEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("message lifecycle data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "role,sessionId,version") {
+        throw new Error("message lifecycle data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("message lifecycle data.version must be 1");
+    assertString(value.sessionId, "message lifecycle data.sessionId");
+    assertString(value.role, "message lifecycle data.role");
+    return value;
+}
+export function turnStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TURN_START_EVENT_ID,
+        version: TURN_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/turn.start@1",
+        allowedRegistrationKinds,
+        validate: validateTurnStartEventDataV1,
+    };
+}
+export function turnEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TURN_END_EVENT_ID,
+        version: TURN_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/turn.end@1",
+        allowedRegistrationKinds,
+        validate: validateTurnEndEventDataV1,
+    };
+}
+export function messageStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: MESSAGE_START_EVENT_ID,
+        version: MESSAGE_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/message.start@1",
+        allowedRegistrationKinds,
+        validate: validateMessageBoundaryEventDataV1,
+    };
+}
+export function messageEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: MESSAGE_END_EVENT_ID,
+        version: MESSAGE_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/message.end@1",
+        allowedRegistrationKinds,
+        validate: validateMessageBoundaryEventDataV1,
+    };
+}
+export function validateToolExecutionStartEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.execution.start data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,toolCallId,toolName,version") {
+        throw new Error("tool.execution.start data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("tool.execution.start data.version must be 1");
+    assertString(value.sessionId, "tool.execution.start data.sessionId");
+    assertString(value.toolCallId, "tool.execution.start data.toolCallId");
+    assertString(value.toolName, "tool.execution.start data.toolName");
+    return value;
+}
+export function toolExecutionStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TOOL_EXECUTION_START_EVENT_ID,
+        version: TOOL_EXECUTION_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/tool.execution.start@1",
+        allowedRegistrationKinds,
+        validate: validateToolExecutionStartEventDataV1,
+    };
+}
+export function validateModelSelectEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("model.select data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "id,provider,sessionId,source,version") {
+        throw new Error("model.select data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("model.select data.version must be 1");
+    assertString(value.sessionId, "model.select data.sessionId");
+    assertString(value.provider, "model.select data.provider");
+    assertString(value.id, "model.select data.id");
+    if (value.source !== "set" && value.source !== "cycle" && value.source !== "restore") {
+        throw new Error("model.select data.source is invalid");
+    }
+    return value;
+}
+export function validateThinkingLevelSelectEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("thinking_level.select data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "level,previousLevel,sessionId,version") {
+        throw new Error("thinking_level.select data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("thinking_level.select data.version must be 1");
+    assertString(value.sessionId, "thinking_level.select data.sessionId");
+    assertString(value.level, "thinking_level.select data.level");
+    assertString(value.previousLevel, "thinking_level.select data.previousLevel");
+    return value;
+}
+export function modelSelectEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: MODEL_SELECT_EVENT_ID,
+        version: MODEL_SELECT_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/model.select@1",
+        allowedRegistrationKinds,
+        validate: validateModelSelectEventDataV1,
+    };
+}
+export function thinkingLevelSelectEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: THINKING_LEVEL_SELECT_EVENT_ID,
+        version: THINKING_LEVEL_SELECT_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/thinking_level.select@1",
+        allowedRegistrationKinds,
+        validate: validateThinkingLevelSelectEventDataV1,
+    };
+}
+export function validateSessionInfoChangedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.info.changed data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,version" &&
+        Object.keys(value).sort().join(",") !== "name,sessionId,version") {
+        throw new Error("session.info.changed data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("session.info.changed data.version must be 1");
+    assertString(value.sessionId, "session.info.changed data.sessionId");
+    if (value.name !== undefined)
+        assertString(value.name, "session.info.changed data.name");
+    return value;
+}
+export function validateSessionEntryAppendedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.entry.appended data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "entryId,entryType,sessionId,version") {
+        throw new Error("session.entry.appended data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("session.entry.appended data.version must be 1");
+    assertString(value.sessionId, "session.entry.appended data.sessionId");
+    assertString(value.entryId, "session.entry.appended data.entryId");
+    assertString(value.entryType, "session.entry.appended data.entryType");
+    return value;
+}
+export function sessionInfoChangedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_INFO_CHANGED_EVENT_ID,
+        version: SESSION_INFO_CHANGED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.info.changed@1",
+        allowedRegistrationKinds,
+        validate: validateSessionInfoChangedEventDataV1,
+    };
+}
+export function sessionEntryAppendedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_ENTRY_APPENDED_EVENT_ID,
+        version: SESSION_ENTRY_APPENDED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.entry.appended@1",
+        allowedRegistrationKinds,
+        validate: validateSessionEntryAppendedEventDataV1,
+    };
+}
+export function validateAgentEndEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("agent.end data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "messageCount,sessionId,version") {
+        throw new Error("agent.end data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("agent.end data.version must be 1");
+    assertString(value.sessionId, "agent.end data.sessionId");
+    if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
+        throw new Error("agent.end data.messageCount must be a non-negative safe integer");
+    }
+    return value;
+}
+export function validateBeforeAgentStartEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("before.agent.start data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "hasImages,sessionId,version") {
+        throw new Error("before.agent.start data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("before.agent.start data.version must be 1");
+    assertString(value.sessionId, "before.agent.start data.sessionId");
+    if (typeof value.hasImages !== "boolean")
+        throw new Error("before.agent.start data.hasImages must be a boolean");
+    return value;
+}
+export function agentEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: AGENT_END_EVENT_ID,
+        version: AGENT_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/agent.end@1",
+        allowedRegistrationKinds,
+        validate: validateAgentEndEventDataV1,
+    };
+}
+export function beforeAgentStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: BEFORE_AGENT_START_EVENT_ID,
+        version: BEFORE_AGENT_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/before.agent.start@1",
+        allowedRegistrationKinds,
+        validate: validateBeforeAgentStartEventDataV1,
+    };
+}
+export function validateBeforeAgentStartEventDataV2(value) {
+    if (!isPlainRecord(value))
+        throw new Error("before.agent.start data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "systemPrompt", "systemPromptOptions"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`before.agent.start data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "systemPrompt", "systemPromptOptions"]) {
+        if (!(key in value))
+            throw new Error(`before.agent.start data is missing required field: ${key}`);
+    }
+    if (value.version !== 2)
+        throw new Error("before.agent.start data.version must be 2");
+    assertString(value.sessionId, "before.agent.start data.sessionId");
+    if (typeof value.systemPrompt !== "string") {
+        throw new Error("before.agent.start data.systemPrompt must be a string");
+    }
+    // Only the shape is enforced here: JSON-safety (no functions, cycles, or
+    // non-finite numbers) is already guaranteed because the dispatcher runs the
+    // payload through a detached structured clone before validation, and the
+    // build-options snapshot legitimately carries explicit `undefined` fields.
+    if (!isPlainRecord(value.systemPromptOptions)) {
+        throw new Error("before.agent.start data.systemPromptOptions must be a plain object");
+    }
+    return value;
+}
+export function beforeAgentStartV2EventDefinition() {
+    const allowedRegistrationKinds = ["observe", "transform"];
+    return {
+        id: BEFORE_AGENT_START_EVENT_ID,
+        version: BEFORE_AGENT_START_EVENT_VERSION_V2,
+        phase: "candidate",
+        schema: "agent-forge/before.agent.start@2",
+        allowedRegistrationKinds,
+        validate: validateBeforeAgentStartEventDataV2,
+    };
+}
+export function validateUIPromptBoundaryEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("ui.prompt lifecycle data must be a plain object");
+    const keys = Object.keys(value).sort();
+    if (keys.join(",") !== "kind,sessionId,version" && keys.join(",") !== "kind,sessionId,title,version") {
+        throw new Error("ui.prompt lifecycle data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("ui.prompt lifecycle data.version must be 1");
+    assertString(value.sessionId, "ui.prompt lifecycle data.sessionId");
+    assertString(value.kind, "ui.prompt lifecycle data.kind");
+    if (value.title !== undefined)
+        assertString(value.title, "ui.prompt lifecycle data.title");
+    return value;
+}
+export function validateResourcesDiscoverEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("resources.discover data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "cwd,reason,sessionId,version") {
+        throw new Error("resources.discover data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("resources.discover data.version must be 1");
+    assertString(value.sessionId, "resources.discover data.sessionId");
+    assertString(value.cwd, "resources.discover data.cwd");
+    if (value.reason !== "startup" && value.reason !== "reload") {
+        throw new Error("resources.discover data.reason is invalid");
+    }
+    return value;
+}
+export function uiPromptStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: UI_PROMPT_START_EVENT_ID,
+        version: UI_PROMPT_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/ui.prompt.start@1",
+        allowedRegistrationKinds,
+        validate: validateUIPromptBoundaryEventDataV1,
+    };
+}
+export function uiPromptEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: UI_PROMPT_END_EVENT_ID,
+        version: UI_PROMPT_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/ui.prompt.end@1",
+        allowedRegistrationKinds,
+        validate: validateUIPromptBoundaryEventDataV1,
+    };
+}
+export function resourcesDiscoverEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: RESOURCES_DISCOVER_EVENT_ID,
+        version: RESOURCES_DISCOVER_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/resources.discover@1",
+        allowedRegistrationKinds,
+        validate: validateResourcesDiscoverEventDataV1,
+    };
+}
+function validateResourcesDiscoverContributionV2(value, label) {
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array`);
+    for (const [index, entry] of value.entries()) {
+        if (!isPlainRecord(entry))
+            throw new Error(`${label}[${index}] must be a plain object`);
+        if (Object.keys(entry).sort().join(",") !== "extensionPath,path") {
+            throw new Error(`${label}[${index}] has unsupported fields`);
+        }
+        assertString(entry.path, `${label}[${index}].path`);
+        assertString(entry.extensionPath, `${label}[${index}].extensionPath`);
+    }
+}
+export function validateResourcesDiscoverEventDataV2(value) {
+    if (!isPlainRecord(value))
+        throw new Error("resources.discover data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "cwd", "reason", "skillPaths", "promptPaths", "themePaths"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`resources.discover data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "cwd", "reason"]) {
+        if (!(key in value))
+            throw new Error(`resources.discover data is missing required field: ${key}`);
+    }
+    if (value.version !== 2)
+        throw new Error("resources.discover data.version must be 2");
+    assertString(value.sessionId, "resources.discover data.sessionId");
+    assertString(value.cwd, "resources.discover data.cwd");
+    if (value.reason !== "startup" && value.reason !== "reload") {
+        throw new Error("resources.discover data.reason is invalid");
+    }
+    if (value.skillPaths !== undefined) {
+        validateResourcesDiscoverContributionV2(value.skillPaths, "resources.discover data.skillPaths");
+    }
+    if (value.promptPaths !== undefined) {
+        validateResourcesDiscoverContributionV2(value.promptPaths, "resources.discover data.promptPaths");
+    }
+    if (value.themePaths !== undefined) {
+        validateResourcesDiscoverContributionV2(value.themePaths, "resources.discover data.themePaths");
+    }
+    return value;
+}
+export function resourcesDiscoverV2EventDefinition() {
+    const allowedRegistrationKinds = ["observe", "transform"];
+    return {
+        id: RESOURCES_DISCOVER_EVENT_ID,
+        version: RESOURCES_DISCOVER_EVENT_VERSION_V2,
+        phase: "candidate",
+        schema: "agent-forge/resources.discover@2",
+        allowedRegistrationKinds,
+        validate: validateResourcesDiscoverEventDataV2,
+    };
+}
+export function validateContextAssembledEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("context.assembled data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "messageCount,sessionId,version") {
+        throw new Error("context.assembled data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("context.assembled data.version must be 1");
+    assertString(value.sessionId, "context.assembled data.sessionId");
+    if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
+        throw new Error("context.assembled data.messageCount must be a non-negative safe integer");
+    }
+    return value;
+}
+export function validateInputReceivedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("input.received data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,textLength,version,source".split(",").sort().join(",")) {
+        throw new Error("input.received data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("input.received data.version must be 1");
+    assertString(value.sessionId, "input.received data.sessionId");
+    assertString(value.source, "input.received data.source");
+    if (typeof value.textLength !== "number" || !Number.isSafeInteger(value.textLength) || value.textLength < 0) {
+        throw new Error("input.received data.textLength must be a non-negative safe integer");
+    }
+    return value;
+}
+export function validateUserBashEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("user.bash data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "cwd,excludeFromContext,sessionId,version") {
+        throw new Error("user.bash data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("user.bash data.version must be 1");
+    assertString(value.sessionId, "user.bash data.sessionId");
+    assertString(value.cwd, "user.bash data.cwd");
+    if (typeof value.excludeFromContext !== "boolean") {
+        throw new Error("user.bash data.excludeFromContext must be a boolean");
+    }
+    return value;
+}
+export function contextAssembledEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: CONTEXT_ASSEMBLED_EVENT_ID,
+        version: CONTEXT_ASSEMBLED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/context.assembled@1",
+        allowedRegistrationKinds,
+        validate: validateContextAssembledEventDataV1,
+    };
+}
+export function inputReceivedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: INPUT_RECEIVED_EVENT_ID,
+        version: INPUT_RECEIVED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/input.received@1",
+        allowedRegistrationKinds,
+        validate: validateInputReceivedEventDataV1,
+    };
+}
+export function userBashEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: USER_BASH_EVENT_ID,
+        version: USER_BASH_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/user.bash@1",
+        allowedRegistrationKinds,
+        validate: validateUserBashEventDataV1,
+    };
+}
+export function validateSessionStartEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.start data must be a plain object");
+    const keys = Object.keys(value).sort();
+    if (keys.join(",") !== "reason,sessionId,version" &&
+        keys.join(",") !== "previousSessionFile,reason,sessionId,version") {
+        throw new Error("session.start data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("session.start data.version must be 1");
+    assertString(value.sessionId, "session.start data.sessionId");
+    if (value.reason !== "startup" &&
+        value.reason !== "reload" &&
+        value.reason !== "new" &&
+        value.reason !== "resume" &&
+        value.reason !== "fork") {
+        throw new Error("session.start data.reason is invalid");
+    }
+    if (value.previousSessionFile !== undefined)
+        assertString(value.previousSessionFile, "session.start data.previousSessionFile");
+    return value;
+}
+export function sessionStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_START_EVENT_ID,
+        version: SESSION_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.start@1",
+        allowedRegistrationKinds,
+        validate: validateSessionStartEventDataV1,
+    };
+}
+export function validateModelResponseEventDataV1(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new Error("model.response data must be a plain object");
+    }
+    const record = value;
+    const allowed = new Set([
+        "version",
+        "sessionId",
+        "entryId",
+        "revision",
+        "provider",
+        "model",
+        "stopReason",
+        "message",
+        "errorMessage",
+    ]);
+    const unsupported = Object.keys(record).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`model.response data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "entryId", "revision", "provider", "model", "stopReason", "message"]) {
+        if (!(key in record))
+            throw new Error(`model.response data is missing required field: ${key}`);
+    }
+    if (record.version !== 1)
+        throw new Error("model.response data.version must be 1");
+    assertString(record.sessionId, "model.response data.sessionId");
+    assertString(record.entryId, "model.response data.entryId");
+    assertString(record.provider, "model.response data.provider");
+    assertString(record.model, "model.response data.model");
+    if (record.stopReason !== "pending" &&
+        record.stopReason !== "stop" &&
+        record.stopReason !== "length" &&
+        record.stopReason !== "toolUse" &&
+        record.stopReason !== "error" &&
+        record.stopReason !== "aborted" &&
+        record.stopReason !== "deferred") {
+        throw new Error("model.response data.stopReason is invalid");
+    }
+    if (!record.message || typeof record.message !== "object" || Array.isArray(record.message)) {
+        throw new Error("model.response data.message must be an assistant message object");
+    }
+    const message = record.message;
+    if (message.role !== "assistant")
+        throw new Error("model.response data.message.role must be assistant");
+    if (!isPlainRecord(record.revision))
+        throw new Error("model.response data.revision must be a plain object");
+    const revision = record.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("model.response data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("model.response data.revision.version must be 1");
+    assertString(revision.sessionId, "model.response data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("model.response data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "model.response data.revision.leafId");
+    if (revision.sessionId !== record.sessionId) {
+        throw new Error("model.response data.revision.sessionId must match sessionId");
+    }
+    if (record.errorMessage !== undefined)
+        assertString(record.errorMessage, "model.response data.errorMessage");
+    return value;
+}
+function isPlainRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+export function modelResponseEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: MODEL_RESPONSE_EVENT_ID,
+        version: MODEL_RESPONSE_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/model.response@1",
+        allowedRegistrationKinds,
+        validate: validateModelResponseEventDataV1,
+    };
+}
+const modelStreamEvents = new Set([
+    "start",
+    "text_start",
+    "text_delta",
+    "text_end",
+    "thinking_start",
+    "thinking_delta",
+    "thinking_end",
+    "toolcall_start",
+    "toolcall_delta",
+    "toolcall_end",
+    "done",
+    "error",
+]);
+export function validateModelStreamEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("model.stream data must be a plain object");
+    const allowed = new Set([
+        "version",
+        "sessionId",
+        "streamId",
+        "sequence",
+        "phase",
+        "event",
+        "partial",
+        "terminal",
+        "error",
+    ]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`model.stream data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of [
+        "version",
+        "sessionId",
+        "streamId",
+        "sequence",
+        "phase",
+        "event",
+        "partial",
+        "terminal",
+        "error",
+    ]) {
+        if (!(key in value))
+            throw new Error(`model.stream data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("model.stream data.version must be 1");
+    assertString(value.sessionId, "model.stream data.sessionId");
+    assertString(value.streamId, "model.stream data.streamId");
+    if (typeof value.sequence !== "number" || !Number.isSafeInteger(value.sequence) || value.sequence < 1) {
+        throw new Error("model.stream data.sequence must be a positive safe integer");
+    }
+    if (value.phase !== "raw" && value.phase !== "candidate" && value.phase !== "committed") {
+        throw new Error("model.stream data.phase is invalid");
+    }
+    if (typeof value.event !== "string" || !modelStreamEvents.has(value.event)) {
+        throw new Error("model.stream data.event is invalid");
+    }
+    if (value.phase === "committed" && value.event !== "done" && value.event !== "error") {
+        throw new Error("model.stream committed phase only permits terminal events");
+    }
+    const terminal = value.event === "done" || value.event === "error";
+    if (value.terminal !== terminal)
+        throw new Error("model.stream data.terminal does not match event");
+    if (value.partial !== null)
+        assertJsonSafe(value.partial, "model.stream data.partial");
+    if (terminal && value.event === "done" && value.error !== null) {
+        throw new Error("model.stream done event cannot contain error");
+    }
+    if (terminal && value.event === "error") {
+        if (!isPlainRecord(value.error))
+            throw new Error("model.stream error event requires error object");
+        const errorKeys = Object.keys(value.error);
+        if (errorKeys.some((key) => key !== "code" && key !== "message" && key !== "name")) {
+            throw new Error("model.stream error has unsupported fields");
+        }
+        assertString(value.error.code, "model.stream data.error.code");
+        assertString(value.error.message, "model.stream data.error.message");
+        if (value.error.name !== undefined)
+            assertString(value.error.name, "model.stream data.error.name");
+    }
+    else if (value.error !== null) {
+        throw new Error("model.stream non-terminal event cannot contain error");
+    }
+    return value;
+}
+export function modelStreamEventDefinition() {
+    return {
+        id: MODEL_STREAM_EVENT_ID,
+        version: MODEL_STREAM_EVENT_VERSION,
+        phase: "raw",
+        allowedPhases: ["raw", "candidate", "committed"],
+        schema: "agent-forge/model.stream@1",
+        allowedRegistrationKinds: ["observe"],
+        validate: validateModelStreamEventDataV1,
+    };
+}
+export function validateToolResultEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.result data must be a plain object");
+    const allowed = new Set([
+        "version",
+        "sessionId",
+        "entryId",
+        "revision",
+        "toolCallId",
+        "toolName",
+        "isError",
+        "message",
+    ]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`tool.result data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError", "message"]) {
+        if (!(key in value))
+            throw new Error(`tool.result data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.result data.version must be 1");
+    assertString(value.sessionId, "tool.result data.sessionId");
+    assertString(value.entryId, "tool.result data.entryId");
+    assertString(value.toolCallId, "tool.result data.toolCallId");
+    assertString(value.toolName, "tool.result data.toolName");
+    if (typeof value.isError !== "boolean")
+        throw new Error("tool.result data.isError must be boolean");
+    if (!isPlainRecord(value.message))
+        throw new Error("tool.result data.message must be a tool result message object");
+    if (value.message.role !== "toolResult")
+        throw new Error("tool.result data.message.role must be toolResult");
+    assertString(value.message.toolCallId, "tool.result data.message.toolCallId");
+    assertString(value.message.toolName, "tool.result data.message.toolName");
+    if (!Array.isArray(value.message.content))
+        throw new Error("tool.result data.message.content must be an array");
+    if (typeof value.message.isError !== "boolean")
+        throw new Error("tool.result data.message.isError must be boolean");
+    if (value.message.toolCallId !== value.toolCallId) {
+        throw new Error("tool.result data.message.toolCallId must match toolCallId");
+    }
+    if (value.message.toolName !== value.toolName) {
+        throw new Error("tool.result data.message.toolName must match toolName");
+    }
+    if (value.message.isError !== value.isError) {
+        throw new Error("tool.result data.message.isError must match isError");
+    }
+    if (!isPlainRecord(value.revision))
+        throw new Error("tool.result data.revision must be a plain object");
+    const revision = value.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("tool.result data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("tool.result data.revision.version must be 1");
+    assertString(revision.sessionId, "tool.result data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("tool.result data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "tool.result data.revision.leafId");
+    if (revision.sessionId !== value.sessionId) {
+        throw new Error("tool.result data.revision.sessionId must match sessionId");
+    }
+    return value;
+}
+export function toolResultEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TOOL_RESULT_EVENT_ID,
+        version: TOOL_RESULT_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/tool.result@1",
+        allowedRegistrationKinds,
+        validate: validateToolResultEventDataV1,
+    };
+}
+export function validateToolCallEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.call data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "input"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`tool.call data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "input"]) {
+        if (!(key in value))
+            throw new Error(`tool.call data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.call data.version must be 1");
+    assertString(value.sessionId, "tool.call data.sessionId");
+    assertString(value.toolCallId, "tool.call data.toolCallId");
+    assertString(value.toolName, "tool.call data.toolName");
+    if (!isPlainRecord(value.revision))
+        throw new Error("tool.call data.revision must be a plain object");
+    const revision = value.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("tool.call data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("tool.call data.revision.version must be 1");
+    assertString(revision.sessionId, "tool.call data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("tool.call data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "tool.call data.revision.leafId");
+    if (revision.sessionId !== value.sessionId)
+        throw new Error("tool.call data.revision.sessionId must match sessionId");
+    assertJsonSafe(value.input, "tool.call data.input");
+    return value;
+}
+export function toolCallEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "transform"];
+    return {
+        id: TOOL_CALL_EVENT_ID,
+        version: TOOL_CALL_EVENT_VERSION,
+        phase: "candidate",
+        schema: "agent-forge/tool.call@1",
+        allowedRegistrationKinds,
+        validate: validateToolCallEventDataV1,
+    };
+}
+export function validateToolExecuteEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.execute data must be a plain object");
+    const allowed = new Set([
+        "version",
+        "sessionId",
+        "revision",
+        "toolCallId",
+        "toolName",
+        "input",
+        "isError",
+        "content",
+    ]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`tool.execute data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "input", "isError", "content"]) {
+        if (!(key in value))
+            throw new Error(`tool.execute data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.execute data.version must be 1");
+    assertString(value.sessionId, "tool.execute data.sessionId");
+    assertString(value.toolCallId, "tool.execute data.toolCallId");
+    assertString(value.toolName, "tool.execute data.toolName");
+    if (typeof value.isError !== "boolean")
+        throw new Error("tool.execute data.isError must be boolean");
+    assertJsonSafe(value.input, "tool.execute data.input");
+    validateToolResultRawEventDataV1({
+        version: 1,
+        sessionId: value.sessionId,
+        revision: value.revision,
+        toolCallId: value.toolCallId,
+        toolName: value.toolName,
+        isError: value.isError,
+        content: value.content,
+    });
+    return value;
+}
+export function toolExecuteEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "execute"];
+    return {
+        id: TOOL_EXECUTE_EVENT_ID,
+        version: TOOL_EXECUTE_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/tool.execute@1",
+        allowedRegistrationKinds,
+        validate: validateToolExecuteEventDataV1,
+    };
+}
+export function validateToolCommitEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.commit data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`tool.commit data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError"]) {
+        if (!(key in value))
+            throw new Error(`tool.commit data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.commit data.version must be 1");
+    assertString(value.sessionId, "tool.commit data.sessionId");
+    assertString(value.entryId, "tool.commit data.entryId");
+    assertString(value.toolCallId, "tool.commit data.toolCallId");
+    assertString(value.toolName, "tool.commit data.toolName");
+    if (typeof value.isError !== "boolean")
+        throw new Error("tool.commit data.isError must be boolean");
+    if (!isPlainRecord(value.revision))
+        throw new Error("tool.commit data.revision must be a plain object");
+    const revision = value.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("tool.commit data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("tool.commit data.revision.version must be 1");
+    assertString(revision.sessionId, "tool.commit data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("tool.commit data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "tool.commit data.revision.leafId");
+    if (revision.sessionId !== value.sessionId)
+        throw new Error("tool.commit data.revision.sessionId must match sessionId");
+    return value;
+}
+export function toolCommitEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TOOL_COMMIT_EVENT_ID,
+        version: TOOL_COMMIT_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/tool.commit@1",
+        allowedRegistrationKinds,
+        validate: validateToolCommitEventDataV1,
+    };
+}
+export function validateToolResultRawEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.result.raw data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`tool.result.raw data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]) {
+        if (!(key in value))
+            throw new Error(`tool.result.raw data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.result.raw data.version must be 1");
+    assertString(value.sessionId, "tool.result.raw data.sessionId");
+    assertString(value.toolCallId, "tool.result.raw data.toolCallId");
+    assertString(value.toolName, "tool.result.raw data.toolName");
+    if (typeof value.isError !== "boolean")
+        throw new Error("tool.result.raw data.isError must be boolean");
+    if (!isPlainRecord(value.revision))
+        throw new Error("tool.result.raw data.revision must be a plain object");
+    const revision = value.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("tool.result.raw data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("tool.result.raw data.revision.version must be 1");
+    assertString(revision.sessionId, "tool.result.raw data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("tool.result.raw data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "tool.result.raw data.revision.leafId");
+    if (revision.sessionId !== value.sessionId) {
+        throw new Error("tool.result.raw data.revision.sessionId must match sessionId");
+    }
+    if (!Array.isArray(value.content))
+        throw new Error("tool.result.raw data.content must be an array");
+    for (const [index, content] of value.content.entries()) {
+        if (!isPlainRecord(content))
+            throw new Error(`tool.result.raw data.content[${index}] must be a plain object`);
+        if (content.type === "text") {
+            const keys = Object.keys(content).sort().join(",");
+            if (keys !== "text,type" && keys !== "text,textSignature,type") {
+                throw new Error(`tool.result.raw data.content[${index}] has unsupported text fields`);
+            }
+            assertString(content.text, `tool.result.raw data.content[${index}].text`);
+            if (content.textSignature !== undefined) {
+                assertString(content.textSignature, `tool.result.raw data.content[${index}].textSignature`);
+            }
+            continue;
+        }
+        if (content.type === "image") {
+            if (Object.keys(content).sort().join(",") !== "data,mimeType,type") {
+                throw new Error(`tool.result.raw data.content[${index}] has unsupported image fields`);
+            }
+            assertString(content.data, `tool.result.raw data.content[${index}].data`);
+            assertString(content.mimeType, `tool.result.raw data.content[${index}].mimeType`);
+            continue;
+        }
+        throw new Error(`tool.result.raw data.content[${index}].type is invalid`);
+    }
+    return value;
+}
+export function toolResultRawEventDefinition() {
+    const allowedRegistrationKinds = ["observe"];
+    return {
+        id: TOOL_RESULT_RAW_EVENT_ID,
+        version: TOOL_RESULT_RAW_EVENT_VERSION,
+        phase: "raw",
+        schema: "agent-forge/tool.result.raw@1",
+        allowedRegistrationKinds,
+        validate: validateToolResultRawEventDataV1,
+    };
+}
+export const TOOL_RESULT_TRANSFORM_EVENT_ID = "tool.result.transform";
+export const TOOL_RESULT_TRANSFORM_EVENT_VERSION = 1;
+export function validateToolResultTransformEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.result.transform data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`tool.result.transform data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]) {
+        if (!(key in value))
+            throw new Error(`tool.result.transform data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.result.transform data.version must be 1");
+    assertString(value.sessionId, "tool.result.transform data.sessionId");
+    assertString(value.toolCallId, "tool.result.transform data.toolCallId");
+    assertString(value.toolName, "tool.result.transform data.toolName");
+    if (typeof value.isError !== "boolean")
+        throw new Error("tool.result.transform data.isError must be boolean");
+    if (!isPlainRecord(value.revision))
+        throw new Error("tool.result.transform data.revision must be a plain object");
+    const revision = value.revision;
+    if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
+        throw new Error("tool.result.transform data.revision has unsupported fields");
+    }
+    if (revision.version !== 1)
+        throw new Error("tool.result.transform data.revision.version must be 1");
+    assertString(revision.sessionId, "tool.result.transform data.revision.sessionId");
+    if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
+        throw new Error("tool.result.transform data.revision.sequence must be a non-negative safe integer");
+    }
+    if (revision.leafId !== null)
+        assertString(revision.leafId, "tool.result.transform data.revision.leafId");
+    if (revision.sessionId !== value.sessionId) {
+        throw new Error("tool.result.transform data.revision.sessionId must match sessionId");
+    }
+    if (!Array.isArray(value.content))
+        throw new Error("tool.result.transform data.content must be an array");
+    for (const [index, content] of value.content.entries()) {
+        if (!isPlainRecord(content)) {
+            throw new Error(`tool.result.transform data.content[${index}] must be a plain object`);
+        }
+        if (content.type === "text") {
+            const keys = Object.keys(content).sort().join(",");
+            if (keys !== "text,type" && keys !== "text,textSignature,type") {
+                throw new Error(`tool.result.transform data.content[${index}] has unsupported text fields`);
+            }
+            assertString(content.text, `tool.result.transform data.content[${index}].text`);
+            if (content.textSignature !== undefined) {
+                assertString(content.textSignature, `tool.result.transform data.content[${index}].textSignature`);
+            }
+            continue;
+        }
+        if (content.type === "image") {
+            if (Object.keys(content).sort().join(",") !== "data,mimeType,type") {
+                throw new Error(`tool.result.transform data.content[${index}] has unsupported image fields`);
+            }
+            assertString(content.data, `tool.result.transform data.content[${index}].data`);
+            assertString(content.mimeType, `tool.result.transform data.content[${index}].mimeType`);
+            continue;
+        }
+        throw new Error(`tool.result.transform data.content[${index}].type is invalid`);
+    }
+    return value;
+}
+export function toolResultTransformEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "transform"];
+    return {
+        id: TOOL_RESULT_TRANSFORM_EVENT_ID,
+        version: TOOL_RESULT_TRANSFORM_EVENT_VERSION,
+        phase: "candidate",
+        schema: "agent-forge/tool.result.transform@1",
+        allowedRegistrationKinds,
+        validate: validateToolResultTransformEventDataV1,
+    };
+}
+export function validateOperationEndEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("operation.end data must be a plain object");
+    const allowed = new Set(["version", "operationId", "operationKind", "status", "errorMessage", "reason"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`operation.end data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "operationId", "operationKind", "status"]) {
+        if (!(key in value))
+            throw new Error(`operation.end data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("operation.end data.version must be 1");
+    assertString(value.operationId, "operation.end data.operationId");
+    assertString(value.operationKind, "operation.end data.operationKind");
+    if (value.status !== "succeeded" && value.status !== "failed" && value.status !== "cancelled") {
+        throw new Error("operation.end data.status is invalid");
+    }
+    if (value.errorMessage !== undefined)
+        assertString(value.errorMessage, "operation.end data.errorMessage");
+    if (value.reason !== undefined)
+        assertString(value.reason, "operation.end data.reason");
+    return value;
+}
+export function operationEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: OPERATION_END_EVENT_ID,
+        version: OPERATION_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/operation.end@1",
+        allowedRegistrationKinds,
+        validate: validateOperationEndEventDataV1,
+    };
+}
+export const CAPABILITY_CALL_EVENT_ID = "capability.call";
+export const CAPABILITY_CALL_EVENT_VERSION = 1;
+const capabilityCallEvents = new Set(["start", "cancel", "end"]);
+const capabilityCallStatuses = new Set(["succeeded", "failed", "cancelled"]);
+export function validateCapabilityCallEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("capability.call data must be a plain object");
+    const allowed = new Set([
+        "version",
+        "operationId",
+        "capabilityId",
+        "capabilityVersion",
+        "capabilityKind",
+        "callerPluginId",
+        "providerPluginId",
+        "event",
+        "status",
+        "error",
+    ]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`capability.call data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of [
+        "version",
+        "operationId",
+        "capabilityId",
+        "capabilityVersion",
+        "capabilityKind",
+        "callerPluginId",
+        "providerPluginId",
+        "event",
+    ]) {
+        if (!(key in value))
+            throw new Error(`capability.call data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("capability.call data.version must be 1");
+    assertString(value.operationId, "capability.call data.operationId");
+    assertString(value.capabilityId, "capability.call data.capabilityId");
+    if (typeof value.capabilityVersion !== "number" ||
+        !Number.isSafeInteger(value.capabilityVersion) ||
+        value.capabilityVersion < 1) {
+        throw new Error("capability.call data.capabilityVersion must be a positive safe integer");
+    }
+    if (value.capabilityKind !== "service" &&
+        value.capabilityKind !== "contribution" &&
+        value.capabilityKind !== "transform") {
+        throw new Error("capability.call data.capabilityKind is invalid");
+    }
+    assertString(value.callerPluginId, "capability.call data.callerPluginId");
+    assertString(value.providerPluginId, "capability.call data.providerPluginId");
+    if (typeof value.event !== "string" || !capabilityCallEvents.has(value.event)) {
+        throw new Error("capability.call data.event is invalid");
+    }
+    if ((value.event === "start" || value.event === "cancel") && value.status !== undefined) {
+        throw new Error("capability.call start/cancel must not include status");
+    }
+    if (value.event === "end" && value.status === undefined) {
+        throw new Error("capability.call end requires status");
+    }
+    if (value.status !== undefined) {
+        if (typeof value.status !== "string" || !capabilityCallStatuses.has(value.status)) {
+            throw new Error("capability.call data.status is invalid");
+        }
+    }
+    if (value.error !== undefined) {
+        if (!isPlainRecord(value.error))
+            throw new Error("capability.call data.error must be a plain object");
+        const errorKeys = Object.keys(value.error);
+        if (errorKeys.some((key) => key !== "code" && key !== "message" && key !== "name")) {
+            throw new Error("capability.call data.error has unsupported fields");
+        }
+        if (!("code" in value.error))
+            throw new Error("capability.call data.error is missing required field: code");
+        if (!("message" in value.error))
+            throw new Error("capability.call data.error is missing required field: message");
+        assertString(value.error.code, "capability.call data.error.code");
+        assertString(value.error.message, "capability.call data.error.message");
+        if (value.error.name !== undefined)
+            assertString(value.error.name, "capability.call data.error.name");
+    }
+    if (value.event !== "end" && value.error !== undefined) {
+        throw new Error("capability.call start/cancel must not include error");
+    }
+    if (value.event === "end" && value.status === "succeeded" && value.error !== undefined) {
+        throw new Error("capability.call succeeded end must not include error");
+    }
+    return value;
+}
+export function capabilityCallEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: CAPABILITY_CALL_EVENT_ID,
+        version: CAPABILITY_CALL_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/capability.call@1",
+        allowedRegistrationKinds,
+        validate: validateCapabilityCallEventDataV1,
+    };
+}
+export const OPERATION_START_EVENT_ID = "operation.start";
+export const OPERATION_START_EVENT_VERSION = 1;
+export const OPERATION_STEP_EVENT_ID = "operation.step";
+export const OPERATION_STEP_EVENT_VERSION = 1;
+export function validateOperationStartEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("operation.start data must be a plain object");
+    const keys = Object.keys(value).sort().join(",");
+    if (keys !== "operationId,operationKind,version") {
+        throw new Error("operation.start data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("operation.start data.version must be 1");
+    assertString(value.operationId, "operation.start data.operationId");
+    assertString(value.operationKind, "operation.start data.operationKind");
+    return value;
+}
+export function operationStartEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: OPERATION_START_EVENT_ID,
+        version: OPERATION_START_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/operation.start@1",
+        allowedRegistrationKinds,
+        validate: validateOperationStartEventDataV1,
+    };
+}
+export function validateOperationStepEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("operation.step data must be a plain object");
+    const allowed = new Set(["version", "operationId", "operationKind", "step", "message", "data"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error("operation.step data has unsupported fields");
+    if (value.version !== 1)
+        throw new Error("operation.step data.version must be 1");
+    assertString(value.operationId, "operation.step data.operationId");
+    assertString(value.operationKind, "operation.step data.operationKind");
+    if (typeof value.step !== "number" || !Number.isSafeInteger(value.step) || value.step < 1) {
+        throw new Error("operation.step data.step must be a positive safe integer");
+    }
+    if (value.message !== undefined)
+        assertString(value.message, "operation.step data.message");
+    if (value.data !== undefined)
+        assertJsonSafe(value.data, "operation.step data.data");
+    return value;
+}
+export function operationStepEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: OPERATION_STEP_EVENT_ID,
+        version: OPERATION_STEP_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/operation.step@1",
+        allowedRegistrationKinds,
+        validate: validateOperationStepEventDataV1,
+    };
+}
+export const OPERATION_CANCEL_EVENT_ID = "operation.cancel";
+export const OPERATION_CANCEL_EVENT_VERSION = 1;
+export function validateOperationCancelEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("operation.cancel data must be a plain object");
+    const keys = Object.keys(value).sort().join(",");
+    if (keys !== "operationId,operationKind,version") {
+        throw new Error("operation.cancel data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("operation.cancel data.version must be 1");
+    assertString(value.operationId, "operation.cancel data.operationId");
+    assertString(value.operationKind, "operation.cancel data.operationKind");
+    return value;
+}
+export function operationCancelEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: OPERATION_CANCEL_EVENT_ID,
+        version: OPERATION_CANCEL_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/operation.cancel@1",
+        allowedRegistrationKinds,
+        validate: validateOperationCancelEventDataV1,
+    };
+}
+export const SESSION_AUTO_RETRY_EVENT_ID = "session.auto.retry";
+export const SESSION_AUTO_RETRY_EVENT_VERSION = 1;
+export const SESSION_COMPACTION_DECISION_EVENT_ID = "session.compaction.decision";
+export const SESSION_COMPACTION_DECISION_EVENT_VERSION = 1;
+export const SESSION_COMPACTION_FAILED_EVENT_ID = "session.compaction.failed";
+export const SESSION_COMPACTION_FAILED_EVENT_VERSION = 1;
+function assertNonNegativeSafeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative safe integer`);
+    }
+}
+function assertPositiveSafeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
+}
+export function validateSessionAutoRetryEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.auto.retry data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "attempt", "maxAttempts", "delayMs", "errorMessage"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`session.auto.retry data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "attempt", "maxAttempts", "delayMs", "errorMessage"]) {
+        if (!(key in value))
+            throw new Error(`session.auto.retry data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("session.auto.retry data.version must be 1");
+    assertString(value.sessionId, "session.auto.retry data.sessionId");
+    assertPositiveSafeInteger(value.attempt, "session.auto.retry data.attempt");
+    assertPositiveSafeInteger(value.maxAttempts, "session.auto.retry data.maxAttempts");
+    assertNonNegativeSafeInteger(value.delayMs, "session.auto.retry data.delayMs");
+    assertString(value.errorMessage, "session.auto.retry data.errorMessage");
+    return value;
+}
+export function sessionAutoRetryEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_AUTO_RETRY_EVENT_ID,
+        version: SESSION_AUTO_RETRY_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.auto.retry@1",
+        allowedRegistrationKinds,
+        validate: validateSessionAutoRetryEventDataV1,
+    };
+}
+const sessionCompactionDecisionReasons = new Set(["overflow", "threshold"]);
+function assertOptionalPositiveSafeInteger(value, label) {
+    if (value === undefined)
+        return;
+    assertPositiveSafeInteger(value, label);
+}
+export function validateSessionCompactionDecisionEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.compaction.decision data must be a plain object");
+    const allowed = new Set([
+        "version",
+        "sessionId",
+        "reason",
+        "compact",
+        "willRetry",
+        "contextTokens",
+        "contextWindow",
+        "reserveTokens",
+        "failureMessage",
+    ]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`session.compaction.decision data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "reason", "compact", "willRetry"]) {
+        if (!(key in value))
+            throw new Error(`session.compaction.decision data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("session.compaction.decision data.version must be 1");
+    assertString(value.sessionId, "session.compaction.decision data.sessionId");
+    if (typeof value.reason !== "string" ||
+        !sessionCompactionDecisionReasons.has(value.reason)) {
+        throw new Error("session.compaction.decision data.reason is invalid");
+    }
+    if (typeof value.compact !== "boolean") {
+        throw new Error("session.compaction.decision data.compact must be a boolean");
+    }
+    if (typeof value.willRetry !== "boolean") {
+        throw new Error("session.compaction.decision data.willRetry must be a boolean");
+    }
+    assertOptionalPositiveSafeInteger(value.contextTokens, "session.compaction.decision data.contextTokens");
+    assertOptionalPositiveSafeInteger(value.contextWindow, "session.compaction.decision data.contextWindow");
+    assertOptionalPositiveSafeInteger(value.reserveTokens, "session.compaction.decision data.reserveTokens");
+    if (value.failureMessage !== undefined) {
+        assertString(value.failureMessage, "session.compaction.decision data.failureMessage");
+    }
+    return value;
+}
+export function sessionCompactionDecisionEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_COMPACTION_DECISION_EVENT_ID,
+        version: SESSION_COMPACTION_DECISION_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.compaction.decision@1",
+        allowedRegistrationKinds,
+        validate: validateSessionCompactionDecisionEventDataV1,
+    };
+}
+const sessionCompactionFailedReasons = new Set(["manual", "overflow", "threshold"]);
+export function validateSessionCompactionFailedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.compaction.failed data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "reason", "errorMessage"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`session.compaction.failed data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "reason", "errorMessage"]) {
+        if (!(key in value))
+            throw new Error(`session.compaction.failed data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("session.compaction.failed data.version must be 1");
+    assertString(value.sessionId, "session.compaction.failed data.sessionId");
+    if (typeof value.reason !== "string" ||
+        !sessionCompactionFailedReasons.has(value.reason)) {
+        throw new Error("session.compaction.failed data.reason is invalid");
+    }
+    assertString(value.errorMessage, "session.compaction.failed data.errorMessage");
+    return value;
+}
+export function sessionCompactionFailedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_COMPACTION_FAILED_EVENT_ID,
+        version: SESSION_COMPACTION_FAILED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.compaction.failed@1",
+        allowedRegistrationKinds,
+        validate: validateSessionCompactionFailedEventDataV1,
+    };
+}
+export const SESSION_END_EVENT_ID = "session.end";
+export const SESSION_END_EVENT_VERSION = 1;
+export function validateSessionEndEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("session.end data must be a plain object");
+    if (Object.keys(value).sort().join(",") !== "sessionId,version") {
+        throw new Error("session.end data has unsupported fields");
+    }
+    if (value.version !== 1)
+        throw new Error("session.end data.version must be 1");
+    assertString(value.sessionId, "session.end data.sessionId");
+    return value;
+}
+export function sessionEndEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: SESSION_END_EVENT_ID,
+        version: SESSION_END_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/session.end@1",
+        allowedRegistrationKinds,
+        validate: validateSessionEndEventDataV1,
+    };
+}
+export const AGENT_TASK_SETTLED_EVENT_ID = "agent.task.settled";
+export const AGENT_TASK_SETTLED_EVENT_VERSION = 1;
+const agentTaskSettledStatuses = new Set([
+    "queued",
+    "admitted",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "timed_out",
+    "drain_timeout",
+    "runner_lost",
+]);
+export function validateAgentTaskSettledEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("agent.task.settled data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "taskSessionId", "taskId", "status", "reasonCode"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0) {
+        throw new Error(`agent.task.settled data has unsupported fields: ${unsupported.join(", ")}`);
+    }
+    for (const key of ["version", "sessionId", "taskSessionId", "taskId", "status"]) {
+        if (!(key in value))
+            throw new Error(`agent.task.settled data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("agent.task.settled data.version must be 1");
+    assertString(value.sessionId, "agent.task.settled data.sessionId");
+    assertString(value.taskSessionId, "agent.task.settled data.taskSessionId");
+    assertString(value.taskId, "agent.task.settled data.taskId");
+    if (typeof value.status !== "string" || !agentTaskSettledStatuses.has(value.status)) {
+        throw new Error("agent.task.settled data.status is invalid");
+    }
+    if (value.reasonCode !== undefined)
+        assertString(value.reasonCode, "agent.task.settled data.reasonCode");
+    return value;
+}
+export function agentTaskSettledEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: AGENT_TASK_SETTLED_EVENT_ID,
+        version: AGENT_TASK_SETTLED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/agent.task.settled@1",
+        allowedRegistrationKinds,
+        validate: validateAgentTaskSettledEventDataV1,
+    };
+}
+export function validateToolGateBlockedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("tool.gate.blocked data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "toolCallId", "toolName", "reason"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`tool.gate.blocked data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "toolCallId", "toolName"]) {
+        if (!(key in value))
+            throw new Error(`tool.gate.blocked data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("tool.gate.blocked data.version must be 1");
+    assertString(value.sessionId, "tool.gate.blocked data.sessionId");
+    assertString(value.toolCallId, "tool.gate.blocked data.toolCallId");
+    assertString(value.toolName, "tool.gate.blocked data.toolName");
+    if (value.reason !== undefined)
+        assertString(value.reason, "tool.gate.blocked data.reason");
+    return value;
+}
+export function toolGateBlockedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: TOOL_GATE_BLOCKED_EVENT_ID,
+        version: TOOL_GATE_BLOCKED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/tool.gate.blocked@1",
+        allowedRegistrationKinds,
+        validate: validateToolGateBlockedEventDataV1,
+    };
+}
+export function validateInputGateBlockedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("input.gate.blocked data must be a plain object");
+    const allowed = new Set(["version", "sessionId", "source", "textLength", "reason"]);
+    const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unsupported.length > 0)
+        throw new Error(`input.gate.blocked data has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of ["version", "sessionId", "source", "textLength"]) {
+        if (!(key in value))
+            throw new Error(`input.gate.blocked data is missing required field: ${key}`);
+    }
+    if (value.version !== 1)
+        throw new Error("input.gate.blocked data.version must be 1");
+    assertString(value.sessionId, "input.gate.blocked data.sessionId");
+    assertString(value.source, "input.gate.blocked data.source");
+    if (typeof value.textLength !== "number" || !Number.isInteger(value.textLength) || value.textLength < 0) {
+        throw new Error("input.gate.blocked data.textLength must be a non-negative integer");
+    }
+    if (value.reason !== undefined)
+        assertString(value.reason, "input.gate.blocked data.reason");
+    return value;
+}
+export function inputGateBlockedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: INPUT_GATE_BLOCKED_EVENT_ID,
+        version: INPUT_GATE_BLOCKED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/input.gate.blocked@1",
+        allowedRegistrationKinds,
+        validate: validateInputGateBlockedEventDataV1,
+    };
+}
+//# sourceMappingURL=lifecycle-catalog.js.map