@contractspec/example.agent-console 3.7.7 → 3.8.2

package/dist/node/run/index.js

@@ -78,11 +78,671 @@ var MOCK_AGENTS = [
   }
 ];
 
+// src/run/run.enum.ts
+import { defineEnum } from "@contractspec/lib.schema";
+var RunStatusEnum = defineEnum("RunStatus", [
+  "QUEUED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var RunStepTypeEnum = defineEnum("RunStepType", [
+  "MESSAGE_CREATION",
+  "TOOL_CALL",
+  "TOOL_RESULT",
+  "ERROR"
+]);
+var LogLevelEnum = defineEnum("LogLevel", [
+  "DEBUG",
+  "INFO",
+  "WARN",
+  "ERROR"
+]);
+var GranularityEnum = defineEnum("Granularity", [
+  "hour",
+  "day",
+  "week",
+  "month"
+]);
+
+// src/run/run.schema.ts
+import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
+var RunInputModel = defineSchemaModel({
+  name: "RunInput",
+  description: "Input data for agent execution",
+  fields: {
+    message: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    context: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var RunStepModel = defineSchemaModel({
+  name: "RunStep",
+  description: "Individual step within a run",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepNumber: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    type: { type: RunStepTypeEnum, isOptional: false },
+    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    tokensUsed: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var RunLogModel = defineSchemaModel({
+  name: "RunLog",
+  description: "Execution log entry",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    level: { type: LogLevelEnum, isOptional: false },
+    message: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    data: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    source: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    traceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    spanId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var RunAgentRefModel = defineSchemaModel({
+  name: "RunAgentRef",
+  description: "Agent reference in a run",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    modelProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    modelName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var RunModel = defineSchemaModel({
+  name: "Run",
+  description: "Agent execution instance",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    status: { type: RunStatusEnum, isOptional: false },
+    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    errorCode: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    totalTokens: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    promptTokens: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    completionTokens: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    totalIterations: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false,
+      defaultValue: 0
+    },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    steps: { type: RunStepModel, isArray: true, isOptional: true },
+    logs: { type: RunLogModel, isArray: true, isOptional: true },
+    agent: { type: RunAgentRefModel, isOptional: true }
+  }
+});
+var RunSummaryModel = defineSchemaModel({
+  name: "RunSummary",
+  description: "Summary of a run for list views",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    status: { type: RunStatusEnum, isOptional: false },
+    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    estimatedCostUsd: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    queuedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var TimelineDataPointModel = defineSchemaModel({
+  name: "TimelineDataPoint",
+  description: "Timeline data point for metrics",
+  fields: {
+    period: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    runs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    tokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    costUsd: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    avgDurationMs: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false }
+  }
+});
+
+// src/run/run.operation.ts
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var OWNERS = ["@agent-console-team"];
+var ExecuteAgentCommand = defineCommand({
+  meta: {
+    key: "agent.run.execute",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "execute"],
+    description: "Starts a new agent run with the given input.",
+    goal: "Execute an AI agent with user input.",
+    context: "Called from chat interface or API."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "ExecuteAgentInput",
+      fields: {
+        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        input: { type: RunInputModel, isOptional: false },
+        sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+        stream: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+        maxIterations: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true
+        },
+        timeoutMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ExecuteAgentOutput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        status: { type: RunStatusEnum, isOptional: false },
+        estimatedWaitMs: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true
+        }
+      }
+    }),
+    errors: {
+      AGENT_NOT_FOUND: {
+        description: "The specified agent does not exist",
+        http: 404,
+        gqlCode: "AGENT_NOT_FOUND",
+        when: "Agent ID is invalid"
+      },
+      AGENT_NOT_ACTIVE: {
+        description: "The specified agent is not active",
+        http: 400,
+        gqlCode: "AGENT_NOT_ACTIVE",
+        when: "Agent is in draft/paused/archived state"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "run.started",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["run", "started"],
+        when: "Run is queued",
+        payload: RunSummaryModel
+      }
+    ],
+    audit: ["run.started"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "execute-agent-happy-path",
+        given: ["Agent exists", "Agent is active"],
+        when: ["User submits execution request"],
+        then: ["Run is created", "RunStarted event is emitted"]
+      },
+      {
+        key: "execute-agent-not-active",
+        given: ["Agent exists but is not active"],
+        when: ["User attempts to execute"],
+        then: ["AGENT_NOT_ACTIVE error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "basic-execute",
+        input: { agentId: "agent-123", input: { message: "Hello" } },
+        output: { runId: "run-456", status: "pending", estimatedWaitMs: 5000 }
+      }
+    ]
+  }
+});
+var CancelRunCommand = defineCommand({
+  meta: {
+    key: "agent.run.cancel",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "cancel"],
+    description: "Cancels an in-progress agent run.",
+    goal: "Stop a running agent execution.",
+    context: "Called when user wants to abort a long-running task."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "CancelRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "CancelRunOutput",
+      fields: {
+        success: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+        status: { type: RunStatusEnum, isOptional: false }
+      }
+    }),
+    errors: {
+      RUN_NOT_FOUND: {
+        description: "The specified run does not exist",
+        http: 404,
+        gqlCode: "RUN_NOT_FOUND",
+        when: "Run ID is invalid"
+      },
+      RUN_NOT_CANCELLABLE: {
+        description: "The run cannot be cancelled",
+        http: 400,
+        gqlCode: "RUN_NOT_CANCELLABLE",
+        when: "Run is already completed/failed/cancelled"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "run.cancelled",
+        version: "1.0.0",
+        stability: "stable",
+        owners: [...OWNERS],
+        tags: ["run", "cancelled"],
+        when: "Run is cancelled",
+        payload: RunSummaryModel
+      }
+    ],
+    audit: ["run.cancelled"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "cancel-run-happy-path",
+        given: ["Run exists", "Run is in progress"],
+        when: ["User cancels run"],
+        then: ["Run is cancelled", "RunCancelled event is emitted"]
+      },
+      {
+        key: "cancel-run-already-completed",
+        given: ["Run exists but is already completed"],
+        when: ["User attempts to cancel"],
+        then: ["RUN_NOT_CANCELLABLE error is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "cancel-basic",
+        input: { runId: "run-456", reason: "User requested" },
+        output: { success: true, status: "cancelled" }
+      }
+    ]
+  }
+});
+var GetRunQuery = defineQuery({
+  meta: {
+    key: "agent.run.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "get"],
+    description: "Retrieves a run by its ID with optional details.",
+    goal: "View detailed run information.",
+    context: "Run details page or monitoring."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetRunInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        includeSteps: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+        includeLogs: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+      }
+    }),
+    output: RunModel,
+    errors: {
+      RUN_NOT_FOUND: {
+        description: "The specified run does not exist",
+        http: 404,
+        gqlCode: "RUN_NOT_FOUND",
+        when: "Run ID is invalid"
+      }
+    }
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-happy-path",
+        given: ["Run exists"],
+        when: ["User requests run by ID"],
+        then: ["Run details are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-with-steps",
+        input: { runId: "run-456", includeSteps: true, includeLogs: false },
+        output: { id: "run-456", status: "completed", steps: [] }
+      }
+    ]
+  }
+});
+var ListRunsQuery = defineQuery({
+  meta: {
+    key: "agent.run.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "list"],
+    description: "Lists runs with optional filtering.",
+    goal: "Browse and search run history.",
+    context: "Run history/dashboard view."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "ListRunsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: true
+        },
+        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        userId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        status: { type: RunStatusEnum, isOptional: true },
+        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 20
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "ListRunsOutput",
+      fields: {
+        items: { type: RunSummaryModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-runs-happy-path",
+        given: ["Organization has runs"],
+        when: ["User lists runs"],
+        then: ["Paginated list of runs is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-by-agent",
+        input: { agentId: "agent-123", limit: 20, offset: 0 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var GetRunStepsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getSteps",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "steps"],
+    description: "Retrieves all steps for a specific run.",
+    goal: "View step-by-step execution details.",
+    context: "Run details page - steps tab."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetRunStepsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunStepsOutput",
+      fields: {
+        steps: { type: RunStepModel, isArray: true, isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-steps-happy-path",
+        given: ["Run exists with steps"],
+        when: ["User requests steps"],
+        then: ["Steps list is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-steps-basic",
+        input: { runId: "run-456" },
+        output: { steps: [] }
+      }
+    ]
+  }
+});
+var GetRunLogsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getLogs",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "logs"],
+    description: "Retrieves all logs for a specific run.",
+    goal: "Debug and audit run execution.",
+    context: "Run details page - logs tab."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetRunLogsInput",
+      fields: {
+        runId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+        level: { type: LogLevelEnum, isOptional: true },
+        stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        limit: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 100
+        },
+        offset: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: true,
+          defaultValue: 0
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunLogsOutput",
+      fields: {
+        items: { type: RunLogModel, isArray: true, isOptional: false },
+        total: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-logs-happy-path",
+        given: ["Run exists with logs"],
+        when: ["User requests logs"],
+        then: ["Paginated logs list is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-logs-filtered",
+        input: { runId: "run-456", level: "error", limit: 50 },
+        output: { items: [], total: 0, hasMore: false }
+      }
+    ]
+  }
+});
+var GetRunMetricsQuery = defineQuery({
+  meta: {
+    key: "agent.run.getMetrics",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["run", "metrics"],
+    description: "Retrieves aggregated metrics for runs within a time period.",
+    goal: "Monitor and analyze agent usage.",
+    context: "Analytics dashboard."
+  },
+  io: {
+    input: defineSchemaModel2({
+      name: "GetRunMetricsInput",
+      fields: {
+        organizationId: {
+          type: ScalarTypeEnum2.String_unsecure(),
+          isOptional: false
+        },
+        agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+        startDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+        endDate: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+        granularity: {
+          type: GranularityEnum,
+          isOptional: true,
+          defaultValue: "day"
+        }
+      }
+    }),
+    output: defineSchemaModel2({
+      name: "GetRunMetricsOutput",
+      fields: {
+        totalRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        completedRuns: {
+          type: ScalarTypeEnum2.Int_unsecure(),
+          isOptional: false
+        },
+        failedRuns: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        totalTokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+        totalCostUsd: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        averageDurationMs: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        successRate: {
+          type: ScalarTypeEnum2.Float_unsecure(),
+          isOptional: false
+        },
+        timeline: {
+          type: TimelineDataPointModel,
+          isArray: true,
+          isOptional: false
+        }
+      }
+    })
+  },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "get-run-metrics-happy-path",
+        given: ["Organization has run history"],
+        when: ["User requests metrics for date range"],
+        then: ["Aggregated metrics are returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "get-daily-metrics",
+        input: {
+          organizationId: "org-123",
+          startDate: "2025-01-01",
+          endDate: "2025-01-31",
+          granularity: "day"
+        },
+        output: {
+          totalRuns: 100,
+          completedRuns: 90,
+          failedRuns: 10,
+          totalTokens: 50000,
+          totalCostUsd: 5,
+          averageDurationMs: 2500,
+          successRate: 0.9,
+          timeline: []
+        }
+      }
+    ]
+  }
+});
+
 // src/shared/mock-runs.ts
 var MOCK_RUNS = [
   {
     id: "run-1",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-1",
     agentName: "Customer Support Bot",
     userId: "user-1",
@@ -105,6 +765,7 @@ var MOCK_RUNS = [
   {
     id: "run-2",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-2",
     agentName: "Code Review Assistant",
     userId: "user-2",
@@ -122,6 +783,7 @@ var MOCK_RUNS = [
   {
     id: "run-3",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-1",
     agentName: "Customer Support Bot",
     userId: "user-1",
@@ -143,6 +805,7 @@ var MOCK_RUNS = [
   {
     id: "run-4",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-3",
     agentName: "Data Analyst",
     userId: "user-3",
@@ -164,6 +827,7 @@ var MOCK_RUNS = [
   {
     id: "run-5",
     organizationId: "demo-org",
+    projectId: "demo-project",
     agentId: "agent-2",
     agentName: "Code Review Assistant",
     userId: "user-2",
@@ -185,6 +849,7 @@ var MOCK_RUNS = [
 ];
 
 // src/run/run.handler.ts
+var nextMockRunId = MOCK_RUNS.length + 1;
 async function mockListRunsHandler(input) {
   const { agentId, status, limit = 20, offset = 0 } = input;
   let filtered = [...MOCK_RUNS];
@@ -233,7 +898,7 @@ async function mockExecuteAgentHandler(input) {
   if (agent.status !== "ACTIVE")
     throw new Error("AGENT_NOT_ACTIVE");
   return {
-    runId: `run-${Date.now()}`,
+    runId: `run-${nextMockRunId++}`,
     status: "QUEUED",
     estimatedWaitMs: 500
   };
@@ -400,873 +1065,214 @@ var RunLogEntity = defineEntity({
   enums: [LogLevelEntityEnum]
 });
 
-// src/run/run.enum.ts
-import { defineEnum } from "@contractspec/lib.schema";
-var RunStatusEnum = defineEnum("RunStatus", [
-  "QUEUED",
-  "IN_PROGRESS",
-  "COMPLETED",
-  "FAILED",
-  "CANCELLED",
-  "EXPIRED"
-]);
-var RunStepTypeEnum = defineEnum("RunStepType", [
-  "MESSAGE_CREATION",
-  "TOOL_CALL",
-  "TOOL_RESULT",
-  "ERROR"
-]);
-var LogLevelEnum = defineEnum("LogLevel", [
-  "DEBUG",
-  "INFO",
-  "WARN",
-  "ERROR"
-]);
-var GranularityEnum = defineEnum("Granularity", [
-  "hour",
-  "day",
-  "week",
-  "month"
-]);
-
 // src/run/run.event.ts
 import { defineEvent } from "@contractspec/lib.contracts-spec";
 import {
   defineEnum as defineEnum2,
-  defineSchemaModel,
-  ScalarTypeEnum
+  defineSchemaModel as defineSchemaModel3,
+  ScalarTypeEnum as ScalarTypeEnum3
 } from "@contractspec/lib.schema";
-var OWNERS = ["@agent-console-team"];
-var RunStartedPayload = defineSchemaModel({
+var OWNERS2 = ["@agent-console-team"];
+var RunStartedPayload = defineSchemaModel3({
   name: "RunStartedPayload",
-  description: "Payload for run started event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
-    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var RunStartedEvent = defineEvent({
-  meta: {
-    key: "agent.run.started",
-    version: "1.0.0",
-    description: "An agent run was started.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "started"]
-  },
-  payload: RunStartedPayload
-});
-var RunCompletedPayload = defineSchemaModel({
-  name: "RunCompletedPayload",
-  description: "Payload for run completed event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    output: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
-    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    promptTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    completionTokens: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    },
-    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    estimatedCostUsd: {
-      type: ScalarTypeEnum.Float_unsecure(),
-      isOptional: true
-    },
-    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var RunCompletedEvent = defineEvent({
-  meta: {
-    key: "agent.run.completed",
-    version: "1.0.0",
-    description: "An agent run completed successfully.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "completed"]
-  },
-  payload: RunCompletedPayload
-});
-var RunFailedPayload = defineSchemaModel({
-  name: "RunFailedPayload",
-  description: "Payload for run failed event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    errorCode: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
-    failedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var RunFailedEvent = defineEvent({
-  meta: {
-    key: "agent.run.failed",
-    version: "1.0.0",
-    description: "An agent run encountered an error.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "failed"]
-  },
-  payload: RunFailedPayload
-});
-var RunCancelledPayload = defineSchemaModel({
-  name: "RunCancelledPayload",
-  description: "Payload for run cancelled event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    organizationId: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    agentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    cancelledBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    reason: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    totalTokens: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    totalIterations: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    cancelledAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var RunCancelledEvent = defineEvent({
-  meta: {
-    key: "agent.run.cancelled",
-    version: "1.0.0",
-    description: "An agent run was cancelled by the user.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "cancelled"]
-  },
-  payload: RunCancelledPayload
-});
-var ToolInvokedPayload = defineSchemaModel({
-  name: "ToolInvokedPayload",
-  description: "Payload for tool invoked event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    input: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
-    invokedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var ToolInvokedEvent = defineEvent({
-  meta: {
-    key: "agent.run.toolInvoked",
-    version: "1.0.0",
-    description: "A tool was invoked during an agent run.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "tool", "invoked"]
-  },
-  payload: ToolInvokedPayload
-});
-var ToolCompletedPayload = defineSchemaModel({
-  name: "ToolCompletedPayload",
-  description: "Payload for tool completed event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    toolId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    toolName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    success: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    output: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
-    errorMessage: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    durationMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var ToolCompletedEvent = defineEvent({
-  meta: {
-    key: "agent.run.toolCompleted",
-    version: "1.0.0",
-    description: "A tool invocation completed during an agent run.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "tool", "completed"]
-  },
-  payload: ToolCompletedPayload
-});
-var MessageTypeEnum = defineEnum2("MessageType", ["assistant", "system"]);
-var MessageGeneratedPayload = defineSchemaModel({
-  name: "MessageGeneratedPayload",
-  description: "Payload for message generated event",
-  fields: {
-    runId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    messageType: { type: MessageTypeEnum, isOptional: false },
-    content: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    tokensUsed: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    generatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var MessageGeneratedEvent = defineEvent({
-  meta: {
-    key: "agent.run.messageGenerated",
-    version: "1.0.0",
-    description: "An agent generated a message during a run.",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["run", "message", "generated"]
-  },
-  payload: MessageGeneratedPayload
-});
-
-// src/run/run.schema.ts
-import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var RunInputModel = defineSchemaModel2({
-  name: "RunInput",
-  description: "Input data for agent execution",
-  fields: {
-    message: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    context: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
-  }
-});
-var RunStepModel = defineSchemaModel2({
-  name: "RunStep",
-  description: "Individual step within a run",
-  fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    stepNumber: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    type: { type: RunStepTypeEnum, isOptional: false },
-    toolId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    toolName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    input: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    output: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    status: { type: RunStatusEnum, isOptional: false },
-    errorMessage: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    tokensUsed: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
-    },
-    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
-    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
-  }
-});
-var RunLogModel = defineSchemaModel2({
-  name: "RunLog",
-  description: "Execution log entry",
-  fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    level: { type: LogLevelEnum, isOptional: false },
-    message: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    data: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    source: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    traceId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    spanId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var RunAgentRefModel = defineSchemaModel2({
-  name: "RunAgentRef",
-  description: "Agent reference in a run",
+  description: "Payload for run started event",
   fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    modelProvider: {
-      type: ScalarTypeEnum2.String_unsecure(),
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
       isOptional: false
     },
-    modelName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false }
+    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    input: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var RunModel = defineSchemaModel2({
-  name: "Run",
-  description: "Agent execution instance",
+var RunStartedEvent = defineEvent({
+  meta: {
+    key: "agent.run.started",
+    version: "1.0.0",
+    description: "An agent run was started.",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["run", "started"]
+  },
+  payload: RunStartedPayload
+});
+var RunCompletedPayload = defineSchemaModel3({
+  name: "RunCompletedPayload",
+  description: "Payload for run completed event",
   fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
     organizationId: {
-      type: ScalarTypeEnum2.String_unsecure(),
+      type: ScalarTypeEnum3.String_unsecure(),
       isOptional: false
     },
-    agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    userId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    input: { type: ScalarTypeEnum2.JSONObject(), isOptional: false },
-    output: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    status: { type: RunStatusEnum, isOptional: false },
-    errorMessage: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    errorCode: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    totalTokens: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
-    },
-    promptTokens: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
-    },
+    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    output: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
+    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    promptTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
     completionTokens: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
-    },
-    totalIterations: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false,
-      defaultValue: 0
-    },
-    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
-    estimatedCostUsd: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
+      type: ScalarTypeEnum3.Int_unsecure(),
+      isOptional: false
     },
-    queuedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    steps: { type: RunStepModel, isArray: true, isOptional: true },
-    logs: { type: RunLogModel, isArray: true, isOptional: true },
-    agent: { type: RunAgentRefModel, isOptional: true }
-  }
-});
-var RunSummaryModel = defineSchemaModel2({
-  name: "RunSummary",
-  description: "Summary of a run for list views",
-  fields: {
-    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    agentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    agentName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    status: { type: RunStatusEnum, isOptional: false },
-    totalTokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    durationMs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
     estimatedCostUsd: {
-      type: ScalarTypeEnum2.Float_unsecure(),
+      type: ScalarTypeEnum3.Float_unsecure(),
       isOptional: true
     },
-    queuedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
-  }
-});
-var TimelineDataPointModel = defineSchemaModel2({
-  name: "TimelineDataPoint",
-  description: "Timeline data point for metrics",
-  fields: {
-    period: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    runs: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    tokens: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    costUsd: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    avgDurationMs: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false }
-  }
-});
-
-// src/run/run.operation.ts
-import {
-  defineCommand,
-  defineQuery
-} from "@contractspec/lib.contracts-spec/operations";
-import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
-var OWNERS2 = ["@agent-console-team"];
-var ExecuteAgentCommand = defineCommand({
-  meta: {
-    key: "agent.run.execute",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "execute"],
-    description: "Starts a new agent run with the given input.",
-    goal: "Execute an AI agent with user input.",
-    context: "Called from chat interface or API."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "ExecuteAgentInput",
-      fields: {
-        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        input: { type: RunInputModel, isOptional: false },
-        sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        metadata: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
-        stream: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-        maxIterations: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true
-        },
-        timeoutMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "ExecuteAgentOutput",
-      fields: {
-        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        status: { type: RunStatusEnum, isOptional: false },
-        estimatedWaitMs: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true
-        }
-      }
-    }),
-    errors: {
-      AGENT_NOT_FOUND: {
-        description: "The specified agent does not exist",
-        http: 404,
-        gqlCode: "AGENT_NOT_FOUND",
-        when: "Agent ID is invalid"
-      },
-      AGENT_NOT_ACTIVE: {
-        description: "The specified agent is not active",
-        http: 400,
-        gqlCode: "AGENT_NOT_ACTIVE",
-        when: "Agent is in draft/paused/archived state"
-      }
-    }
-  },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "run.started",
-        version: "1.0.0",
-        stability: "stable",
-        owners: [...OWNERS2],
-        tags: ["run", "started"],
-        when: "Run is queued",
-        payload: RunSummaryModel
-      }
-    ],
-    audit: ["run.started"]
-  },
-  acceptance: {
-    scenarios: [
-      {
-        key: "execute-agent-happy-path",
-        given: ["Agent exists", "Agent is active"],
-        when: ["User submits execution request"],
-        then: ["Run is created", "RunStarted event is emitted"]
-      },
-      {
-        key: "execute-agent-not-active",
-        given: ["Agent exists but is not active"],
-        when: ["User attempts to execute"],
-        then: ["AGENT_NOT_ACTIVE error is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "basic-execute",
-        input: { agentId: "agent-123", input: { message: "Hello" } },
-        output: { runId: "run-456", status: "pending", estimatedWaitMs: 5000 }
-      }
-    ]
-  }
-});
-var CancelRunCommand = defineCommand({
-  meta: {
-    key: "agent.run.cancel",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["run", "cancel"],
-    description: "Cancels an in-progress agent run.",
-    goal: "Stop a running agent execution.",
-    context: "Called when user wants to abort a long-running task."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "CancelRunInput",
-      fields: {
-        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        reason: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "CancelRunOutput",
-      fields: {
-        success: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
-        status: { type: RunStatusEnum, isOptional: false }
-      }
-    }),
-    errors: {
-      RUN_NOT_FOUND: {
-        description: "The specified run does not exist",
-        http: 404,
-        gqlCode: "RUN_NOT_FOUND",
-        when: "Run ID is invalid"
-      },
-      RUN_NOT_CANCELLABLE: {
-        description: "The run cannot be cancelled",
-        http: 400,
-        gqlCode: "RUN_NOT_CANCELLABLE",
-        when: "Run is already completed/failed/cancelled"
-      }
-    }
-  },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "run.cancelled",
-        version: "1.0.0",
-        stability: "stable",
-        owners: [...OWNERS2],
-        tags: ["run", "cancelled"],
-        when: "Run is cancelled",
-        payload: RunSummaryModel
-      }
-    ],
-    audit: ["run.cancelled"]
-  },
-  acceptance: {
-    scenarios: [
-      {
-        key: "cancel-run-happy-path",
-        given: ["Run exists", "Run is in progress"],
-        when: ["User cancels run"],
-        then: ["Run is cancelled", "RunCancelled event is emitted"]
-      },
-      {
-        key: "cancel-run-already-completed",
-        given: ["Run exists but is already completed"],
-        when: ["User attempts to cancel"],
-        then: ["RUN_NOT_CANCELLABLE error is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "cancel-basic",
-        input: { runId: "run-456", reason: "User requested" },
-        output: { success: true, status: "cancelled" }
-      }
-    ]
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var GetRunQuery = defineQuery({
+var RunCompletedEvent = defineEvent({
   meta: {
-    key: "agent.run.get",
+    key: "agent.run.completed",
     version: "1.0.0",
+    description: "An agent run completed successfully.",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["run", "get"],
-    description: "Retrieves a run by its ID with optional details.",
-    goal: "View detailed run information.",
-    context: "Run details page or monitoring."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "GetRunInput",
-      fields: {
-        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        includeSteps: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-        includeLogs: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-      }
-    }),
-    output: RunModel,
-    errors: {
-      RUN_NOT_FOUND: {
-        description: "The specified run does not exist",
-        http: 404,
-        gqlCode: "RUN_NOT_FOUND",
-        when: "Run ID is invalid"
-      }
-    }
-  },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "get-run-happy-path",
-        given: ["Run exists"],
-        when: ["User requests run by ID"],
-        then: ["Run details are returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "get-with-steps",
-        input: { runId: "run-456", includeSteps: true, includeLogs: false },
-        output: { id: "run-456", status: "completed", steps: [] }
-      }
-    ]
+    tags: ["run", "completed"]
+  },
+  payload: RunCompletedPayload
+});
+var RunFailedPayload = defineSchemaModel3({
+  name: "RunFailedPayload",
+  description: "Payload for run failed event",
+  fields: {
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    agentName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    errorMessage: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    errorCode: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
+    failedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var ListRunsQuery = defineQuery({
+var RunFailedEvent = defineEvent({
   meta: {
-    key: "agent.run.list",
+    key: "agent.run.failed",
     version: "1.0.0",
+    description: "An agent run encountered an error.",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["run", "list"],
-    description: "Lists runs with optional filtering.",
-    goal: "Browse and search run history.",
-    context: "Run history/dashboard view."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "ListRunsInput",
-      fields: {
-        organizationId: {
-          type: ScalarTypeEnum3.String_unsecure(),
-          isOptional: true
-        },
-        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        sessionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        status: { type: RunStatusEnum, isOptional: true },
-        startDate: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
-        endDate: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
-        limit: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 20
-        },
-        offset: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 0
-        }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "ListRunsOutput",
-      fields: {
-        items: { type: RunSummaryModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
-      }
-    })
+    tags: ["run", "failed"]
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "list-runs-happy-path",
-        given: ["Organization has runs"],
-        when: ["User lists runs"],
-        then: ["Paginated list of runs is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "list-by-agent",
-        input: { agentId: "agent-123", limit: 20, offset: 0 },
-        output: { items: [], total: 0, hasMore: false }
-      }
-    ]
+  payload: RunFailedPayload
+});
+var RunCancelledPayload = defineSchemaModel3({
+  name: "RunCancelledPayload",
+  description: "Payload for run cancelled event",
+  fields: {
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    organizationId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    cancelledBy: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    reason: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    totalIterations: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    cancelledAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var GetRunStepsQuery = defineQuery({
+var RunCancelledEvent = defineEvent({
   meta: {
-    key: "agent.run.getSteps",
+    key: "agent.run.cancelled",
     version: "1.0.0",
+    description: "An agent run was cancelled by the user.",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["run", "steps"],
-    description: "Retrieves all steps for a specific run.",
-    goal: "View step-by-step execution details.",
-    context: "Run details page - steps tab."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "GetRunStepsInput",
-      fields: {
-        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "GetRunStepsOutput",
-      fields: {
-        steps: { type: RunStepModel, isArray: true, isOptional: false }
-      }
-    })
+    tags: ["run", "cancelled"]
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "get-run-steps-happy-path",
-        given: ["Run exists with steps"],
-        when: ["User requests steps"],
-        then: ["Steps list is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "get-steps-basic",
-        input: { runId: "run-456" },
-        output: { steps: [] }
-      }
-    ]
+  payload: RunCancelledPayload
+});
+var ToolInvokedPayload = defineSchemaModel3({
+  name: "ToolInvokedPayload",
+  description: "Payload for tool invoked event",
+  fields: {
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    input: { type: ScalarTypeEnum3.JSONObject(), isOptional: false },
+    invokedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var GetRunLogsQuery = defineQuery({
+var ToolInvokedEvent = defineEvent({
   meta: {
-    key: "agent.run.getLogs",
+    key: "agent.run.toolInvoked",
     version: "1.0.0",
+    description: "A tool was invoked during an agent run.",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["run", "logs"],
-    description: "Retrieves all logs for a specific run.",
-    goal: "Debug and audit run execution.",
-    context: "Run details page - logs tab."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "GetRunLogsInput",
-      fields: {
-        runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-        level: { type: LogLevelEnum, isOptional: true },
-        stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        limit: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 100
-        },
-        offset: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: true,
-          defaultValue: 0
-        }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "GetRunLogsOutput",
-      fields: {
-        items: { type: RunLogModel, isArray: true, isOptional: false },
-        total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: false }
-      }
-    })
+    tags: ["run", "tool", "invoked"]
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "get-run-logs-happy-path",
-        given: ["Run exists with logs"],
-        when: ["User requests logs"],
-        then: ["Paginated logs list is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "get-logs-filtered",
-        input: { runId: "run-456", level: "error", limit: 50 },
-        output: { items: [], total: 0, hasMore: false }
-      }
-    ]
+  payload: ToolInvokedPayload
+});
+var ToolCompletedPayload = defineSchemaModel3({
+  name: "ToolCompletedPayload",
+  description: "Payload for tool completed event",
+  fields: {
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    toolId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    toolName: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    success: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+    output: { type: ScalarTypeEnum3.JSONObject(), isOptional: true },
+    errorMessage: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    durationMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
-var GetRunMetricsQuery = defineQuery({
+var ToolCompletedEvent = defineEvent({
   meta: {
-    key: "agent.run.getMetrics",
+    key: "agent.run.toolCompleted",
     version: "1.0.0",
+    description: "A tool invocation completed during an agent run.",
     stability: "stable",
     owners: [...OWNERS2],
-    tags: ["run", "metrics"],
-    description: "Retrieves aggregated metrics for runs within a time period.",
-    goal: "Monitor and analyze agent usage.",
-    context: "Analytics dashboard."
-  },
-  io: {
-    input: defineSchemaModel3({
-      name: "GetRunMetricsInput",
-      fields: {
-        organizationId: {
-          type: ScalarTypeEnum3.String_unsecure(),
-          isOptional: false
-        },
-        agentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-        startDate: { type: ScalarTypeEnum3.DateTime(), isOptional: false },
-        endDate: { type: ScalarTypeEnum3.DateTime(), isOptional: false },
-        granularity: {
-          type: GranularityEnum,
-          isOptional: true,
-          defaultValue: "day"
-        }
-      }
-    }),
-    output: defineSchemaModel3({
-      name: "GetRunMetricsOutput",
-      fields: {
-        totalRuns: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        completedRuns: {
-          type: ScalarTypeEnum3.Int_unsecure(),
-          isOptional: false
-        },
-        failedRuns: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        totalTokens: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-        totalCostUsd: {
-          type: ScalarTypeEnum3.Float_unsecure(),
-          isOptional: false
-        },
-        averageDurationMs: {
-          type: ScalarTypeEnum3.Float_unsecure(),
-          isOptional: false
-        },
-        successRate: {
-          type: ScalarTypeEnum3.Float_unsecure(),
-          isOptional: false
-        },
-        timeline: {
-          type: TimelineDataPointModel,
-          isArray: true,
-          isOptional: false
-        }
-      }
-    })
+    tags: ["run", "tool", "completed"]
   },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "get-run-metrics-happy-path",
-        given: ["Organization has run history"],
-        when: ["User requests metrics for date range"],
-        then: ["Aggregated metrics are returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "get-daily-metrics",
-        input: {
-          organizationId: "org-123",
-          startDate: "2025-01-01",
-          endDate: "2025-01-31",
-          granularity: "day"
-        },
-        output: {
-          totalRuns: 100,
-          completedRuns: 90,
-          failedRuns: 10,
-          totalTokens: 50000,
-          totalCostUsd: 5,
-          averageDurationMs: 2500,
-          successRate: 0.9,
-          timeline: []
-        }
-      }
-    ]
+  payload: ToolCompletedPayload
+});
+var MessageTypeEnum = defineEnum2("MessageType", ["assistant", "system"]);
+var MessageGeneratedPayload = defineSchemaModel3({
+  name: "MessageGeneratedPayload",
+  description: "Payload for message generated event",
+  fields: {
+    runId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    messageType: { type: MessageTypeEnum, isOptional: false },
+    content: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    tokensUsed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    generatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
   }
 });
+var MessageGeneratedEvent = defineEvent({
+  meta: {
+    key: "agent.run.messageGenerated",
+    version: "1.0.0",
+    description: "An agent generated a message during a run.",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["run", "message", "generated"]
+  },
+  payload: MessageGeneratedPayload
+});
 
 // src/run/run.presentation.ts
 import {