@vantageos/agent-engine 0.1.0-alpha.7 → 0.3.0-alpha.0

package/dist/component/schema.js

@@ -1,27 +1,6 @@
 import { defineSchema, defineTable } from "convex/server";
 import { v } from "convex/values";
-// @vantageos/agent-engine — COMPONENT schema (T2-QUATER).
-//
-// This is the schema that actually ships INSIDE the published package and
-// is deployed under the component boundary when a consumer registers
-// `app.use(agentEngine)` — as opposed to `convex/schema.ts` at the repo
-// root, which only backs THIS repo's own dev/test deployment.
-//
-// SCOPE (T2-QUATER: durableJob only. T2-QUINQUIES, this pass: WIDENS the
-// boundary to the SESSIONS surface a downstream conversation-thread
-// consumer needs — session start/turn, streamed reasoning/tool-call events,
-// toolApprovals response, replay on reconnect, dynamic resolver — see
-// README "What's callable"). Still DELIBERATELY NARROW: `skills`,
-// `connections`, `subagents`, `habits`, `sandboxConfig`, `modelKeys`,
-// `mandates`, `awaitEventTimeouts`, `wakeableWork` are NOT re-hosted here —
-// each of those needs its own component-level test harness first (Day 128:
-// never ship unverified). `agents` is included, minimally, because a
-// session cannot exist without an owning agent row the component itself
-// can read (component isolation: this package cannot read a consumer app's
-// OWN `agents` table across the component boundary).
 export default defineSchema({
-    // durableJobs — GENERIC durable step-batch primitive. See
-    // engine/durableJob.ts for the full contract description.
     durableJobs: defineTable({
         orgId: v.string(),
         kind: v.string(),
@@ -39,11 +18,6 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_status", ["orgId", "status"]),
-    // callerStepInvocations — TEST-ONLY fixture table, see
-    // convex/component/testFixtures/callerSteps.ts. Not part of the public
-    // contract; kept so the component-level test harness can prove the
-    // deterministic-replay / abandon-after-N properties the same way the
-    // repo-root test suite does.
     callerStepInvocations: defineTable({
         orgId: v.string(),
         jobId: v.id("durableJobs"),
@@ -52,24 +26,16 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_job", ["orgId", "jobId"]),
-    // ---------------------------------------------------------------------
-    // T2-QUINQUIES — SESSIONS surface (EveVantage V4 conversation thread).
-    // ---------------------------------------------------------------------
-    // agents — minimal root sheet, ONLY the fields the sessions surface
-    // needs to resolve a manifest (name/instructions/model) + gate tool
-    // calls (via toolApprovals below). The full agent aggregate (skills,
-    // connections, subagents, habits, sandboxConfig, modelKeys) stays out of
-    // this component boundary for this pass — see the SCOPE note above.
     agents: defineTable({
         orgId: v.string(),
         name: v.string(),
-        description: v.optional(v.string()), // eve: agent-definition.ts:291
+        description: v.optional(v.string()),
         instructions: v.string(),
         model: v.string(),
-        reasoningEffort: v.optional(v.union(v.literal("none"), v.literal("low"), v.literal("medium"), v.literal("high"))), // eve: agent-definition.ts:315-319
-        modelProvider: v.optional(v.union(v.literal("gateway"), v.literal("openrouter"))), // intentional divergence from Eve (bring-your-own-key); optional so it stays additive/backwards-compatible with rows created before this field existed
-        maxSubagents: v.optional(v.number()), // eve: agent-definition.ts:163-179, default 100
-        maxInputTokensPerSession: v.optional(v.union(v.number(), v.literal(false))), // eve: :195, false = unlimited
+        reasoningEffort: v.optional(v.union(v.literal("none"), v.literal("low"), v.literal("medium"), v.literal("high"))),
+        modelProvider: v.optional(v.union(v.literal("gateway"), v.literal("openrouter"))),
+        maxSubagents: v.optional(v.number()),
+        maxInputTokensPerSession: v.optional(v.union(v.number(), v.literal(false))),
         status: v.union(v.literal("draft"), v.literal("live"), v.literal("archived")),
         createdBy: v.string(),
         createdAt: v.number(),
@@ -77,11 +43,6 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_status", ["orgId", "status"]),
-    // toolApprovals — approval gate per (agent, tool), eve parity
-    // (public/definitions/tool.ts:117-125). "never" (default) means a tool
-    // call never pauses for human approval; "always"/"once" gate every /
-    // first call of a session via a `tool.approval.requested` sessionEvent
-    // that `toolApprovals.respond` resolves.
     toolApprovals: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
@@ -93,12 +54,6 @@ export default defineSchema({
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"])
         .index("by_org_agent_tool", ["orgId", "agentId", "toolName"]),
-    // sessions — one conversation container per `sessions.start` call.
-    // "intentional divergence from Eve": a session is piloted by a VERSIONED
-    // `@convex-dev/workflow` run (engine/workflows.ts: sessionWorkflowV1), so
-    // a turn survives a deploy. `workflowId`/`workflowVersion` are optional:
-    // rows written before that workflow existed stay valid without a backfill,
-    // and a consumer driving turns itself may leave them unset.
     sessions: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
@@ -111,84 +66,28 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"]),
-    // sessionEvents — the append-only event log a client replays on
-    // reconnect (`sessions.listEvents`) and that IS the streaming transport:
-    // Convex query subscriptions push new rows to every subscriber in real
-    // time, so "streaming the reasoning and tool calls" is simply inserting
-    // rows here as they happen and letting reactivity carry them to the
-    // client — no separate transport needed. Event names mirror eve's
-    // session/turn boundaries (`session.started`, `turn.started`,
-    // dynamic-tool-definition.ts:40-46) plus the turn-body events this pass
-    // adds (reasoning chunks, tool-call lifecycle, approval lifecycle).
     sessionEvents: defineTable({
         orgId: v.string(),
         sessionId: v.id("sessions"),
-        name: v.union(v.literal("session.started"), v.literal("turn.started"), v.literal("turn.reasoning"), v.literal("turn.toolCall.requested"), v.literal("turn.toolCall.completed"), 
-        // "intentional divergence from Eve" (VP k17ea6x3tht8xa3rxm139t23gx8ajkf3, defaut 2):
-        // explicit terminal state for a one-turn approval REFUSAL, distinct
-        // from "turn.toolCall.completed" (tool actually ran). Without this,
-        // a denied tool call had no event of its own -- a consumer had no
-        // way to tell "refused this turn" from "skipped, turn completed
-        // anyway", which is the wrong default a consumer had to code around.
-        v.literal("turn.toolCall.denied"), v.literal("turn.completed"), v.literal("tool.approval.requested"), v.literal("tool.approval.resolved"), 
-        // Blank event auto-inserted by `engine/awaitEventTimeout.fire`
-        // (workflow#177: Convex provides no native timeout for
-        // `step.awaitEvent`). See engine/awaitEventTimeout.ts.
-        v.literal("sandbox.timeout")),
-        payload: v.optional(v.string()), // JSON-serialized, free contract per event name
+        name: v.union(v.literal("session.started"), v.literal("turn.started"), v.literal("turn.reasoning"), v.literal("turn.toolCall.requested"), v.literal("turn.toolCall.completed"), v.literal("turn.toolCall.denied"), v.literal("turn.completed"), v.literal("tool.approval.requested"), v.literal("tool.approval.resolved"), v.literal("sandbox.timeout")),
+        payload: v.optional(v.string()),
         createdAt: v.number(),
     })
         .index("by_org", ["orgId"])
         .index("by_org_session", ["orgId", "sessionId"]),
-    // ---------------------------------------------------------------------
-    // WAKE-UP WITHOUT POLLING. See engine/wakeup.ts and
-    // engine/awaitEventTimeout.ts for the mechanism itself.
-    // ---------------------------------------------------------------------
-    // wakeableWork — GENERIC wake-up primitive. `enqueue` puts caller-supplied
-    // work (an action, referenced by an opaque function-handle string) into a
-    // dedicated `@convex-dev/workpool`; that pool's `onComplete` callback
-    // calls `workflow.sendEvent(...)` against the CALLER-supplied
-    // `workflowId` the instant the work resolves — success, failure, OR
-    // cancellation alike. Zero setInterval, zero cron.
-    wakeableWork: defineTable({
-        orgId: v.string(),
-        workflowId: v.string(), // target: the workflow parked on step.awaitEvent
-        awaitedEventName: v.string(), // event name that workflow is awaiting
-        workId: v.string(), // @convex-dev/workpool WorkId, opaque string
-        status: v.union(v.literal("pending"), v.literal("completed"), // work succeeded
-        v.literal("failed"), // work threw
-        v.literal("cancelled")),
-        resultSummary: v.optional(v.string()), // error message when status=="failed"
-        createdAt: v.number(),
-        updatedAt: v.number(),
-    })
-        .index("by_org", ["orgId"])
-        .index("by_org_workflow", ["orgId", "workflowId"]),
-    // awaitEventTimeouts — self-built timeout for `step.awaitEvent`
-    // (workflow#177: "Convex does not provide a native timeout for
-    // awaitEvent"). A scheduled mutation (`ctx.scheduler.runAfter`) fires a
-    // blank `sandbox.timeout` sessionEvent if the awaited event never arrives
-    // before `deadlineAt`.
     awaitEventTimeouts: defineTable({
         orgId: v.string(),
-        sessionId: v.id("sessions"),
+        runId: v.optional(v.string()),
+        sessionId: v.optional(v.id("sessions")),
         awaitedEventName: v.string(),
         deadlineAt: v.number(),
-        // optional: patched right after insert, once the scheduled function
-        // itself has been created (it needs this row's id as its argument).
         scheduledFunctionId: v.optional(v.id("_scheduled_functions")),
         firedAt: v.optional(v.number()),
         cancelledAt: v.optional(v.number()),
     })
         .index("by_org", ["orgId"])
-        .index("by_org_session", ["orgId", "sessionId"]),
-    // wakeupDemoResults — TEST-ONLY fixture, see
-    // component/testFixtures/wakeupDemoWorkflow.ts. Not part of the public
-    // contract; a reference recipient workflow parked on `step.awaitEvent`
-    // patches `wokenAt`/`observedStatus` here ONLY after
-    // `engine/wakeup.onWorkComplete` has called `sendEvent` -- its presence
-    // is the test-observable proof that the wake mechanism (not a poll)
-    // resumed the workflow. Same discipline as `callerStepInvocations` above.
+        .index("by_org_session", ["orgId", "sessionId"])
+        .index("by_org_run", ["orgId", "runId"]),
     wakeupDemoResults: defineTable({
         orgId: v.string(),
         enqueuedAt: v.number(),
@@ -196,23 +95,13 @@ export default defineSchema({
         observedStatus: v.optional(v.union(v.literal("completed"), v.literal("failed"), v.literal("cancelled"))),
         observedResultSummary: v.optional(v.string()),
     }).index("by_org", ["orgId"]),
-    // ---------------------------------------------------------------------
-    // MANDATES — "intentional divergence from Eve": bounded authority. See
-    // engine/mandates.ts and engine/wakeup.ts, where `enqueue` funds through
-    // `mandates.spendInternal` before any work can enter the wakeup pool.
-    // ---------------------------------------------------------------------
-    // mandates — a cap is a DATA row scoped by orgId + agentId + scope,
-    // never a constant read from code. `kind`/`rate`/`period`/`capacity` are
-    // the inline contract of @convex-dev/rate-limiter ("dynamic config"): the
-    // COST (`count`) is a WEIGHTED count (tokens/euros/calls), never a plain
-    // call counter. Changing a cap is a row mutation, never a deployment.
     mandates: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
-        scope: v.string(), // free-form business name (e.g. "llm-tokens") -- DATA, not a constant
+        scope: v.string(),
         kind: v.union(v.literal("token bucket"), v.literal("fixed window")),
         rate: v.number(),
-        period: v.number(), // ms
+        period: v.number(),
         capacity: v.optional(v.number()),
         createdAt: v.number(),
         updatedAt: v.number(),
@@ -220,9 +109,6 @@ export default defineSchema({
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"])
         .index("by_org_agent_scope", ["orgId", "agentId", "scope"]),
-    // approvalRequests — created whenever a mandate is exceeded. NEVER a
-    // silent bypass: an overrun always becomes a persisted HUMAN approval
-    // request, never a silent refusal with no trace.
     approvalRequests: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
@@ -237,77 +123,15 @@ export default defineSchema({
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"])
         .index("by_org_status", ["orgId", "status"]),
-    // ---------------------------------------------------------------------
-    // HABITS — "intentional divergence from Eve": a habit is a DYNAMIC cron
-    // per agent/org, which is what turns a chat into an employee. See
-    // engine/habits.ts; `crons` is a sub-component of THIS component,
-    // registered in component/convex.config.ts.
-    // ---------------------------------------------------------------------
-    // habits — a schedule is a DATA row scoped by orgId + agentId, never a
-    // constant read from a deployed `convex/crons.ts`. `cronExpression` is
-    // the DATA that drives the runtime cron registered via
-    // `@convex-dev/crons`; create/updateSchedule/enable/disable never
-    // redeploy anything.
-    habits: defineTable({
-        orgId: v.string(),
-        agentId: v.id("agents"),
-        name: v.string(),
-        cronExpression: v.string(),
-        prompt: v.string(),
-        enabled: v.boolean(),
-        // id of the runtime-registered @convex-dev/crons job, present only
-        // while `enabled` is true (cleared by `disable`, reassigned by
-        // `enable` / `updateSchedule` -- no redeploy involved in any transition).
-        cronJobId: v.optional(v.string()),
-        lastRunAt: v.optional(v.number()),
-        createdAt: v.number(),
-        updatedAt: v.number(),
-    })
-        .index("by_org", ["orgId"])
-        .index("by_org_agent", ["orgId", "agentId"]),
-    // habitRuns — proof of execution of a habit (MUST_PASS/MUST_BLOCK probe,
-    // component/habits.componentPackaging.test.ts). Every tick of the runtime
-    // cron registered via @convex-dev/crons writes a row here -- this is what
-    // makes "fires its first run without a deploy" PROVABLE rather than
-    // asserted on trust.
-    habitRuns: defineTable({
-        orgId: v.string(),
-        habitId: v.id("habits"),
-        agentId: v.id("agents"),
-        ranAt: v.number(),
-    })
-        .index("by_org", ["orgId"])
-        .index("by_org_habit", ["orgId", "habitId"]),
-    // ---------------------------------------------------------------------
-    // SANDBOX BRIDGE — the same pause/wake mechanism serves both the sandbox
-    // and agent-to-agent delegation. See engine/sandboxCallback.ts.
-    //
-    // BOUNDARY, and why it is where it is: the "use node" action
-    // that actually talks to `@vercel/sandbox` CANNOT live inside this
-    // component — the
-    // Convex CLI's own component bundler HARD-CRASHES on any "use node" file
-    // found in a child component directory ("use node directive is not
-    // supported in components", node_modules/convex/dist/cjs/cli/lib/
-    // components/definition/bundle.js). It stays app-level and calls INTO
-    // this component's public `engine.sandboxCallback.startRun` /
-    // `attachSandboxId` (and `engine.mandates.spend`) instead. Likewise, no
-    // official `@convex-dev/*` component ships an `http.ts` or reads
-    // `process.env` directly (measured: zero hits across all 7 installed
-    // `@convex-dev/*` component dist trees) — the signed callback's public
-    // HTTP route (`/sandbox/callback`) and its `SANDBOX_CALLBACK_SECRET`
-    // read + HMAC verification stay in the CONSUMER app's `convex/http.ts`,
-    // which delegates to this component's public
-    // `engine.sandboxCallback.processCallback` /
-    // `engine.sandboxCallback.deadLetterMalformed` ONLY after the signature
-    // has already checked out.
     sandboxConfig: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
-        provider: v.literal("vercel-sandbox"),
+        provider: v.union(v.literal("vercel-sandbox"), v.literal("e2b"), v.literal("daytona"), v.literal("box")),
         image: v.optional(v.string()),
         timeoutSeconds: v.number(),
         egressPolicy: v.union(v.literal("allow-all"), v.literal("deny-all-allowlist")),
         allowlistDomains: v.array(v.string()),
+        boxId: v.optional(v.string()),
         createdAt: v.number(),
         updatedAt: v.number(),
     })
@@ -315,9 +139,9 @@ export default defineSchema({
         .index("by_org_agent", ["orgId", "agentId"]),
     sandboxRuns: defineTable({
         orgId: v.string(),
-        workflowId: v.string(), // target: the workflow parked on step.awaitEvent
-        awaitedEventName: v.string(), // event name that workflow is awaiting
-        sandboxId: v.string(), // Vercel Sandbox id (opaque, from Sandbox.create())
+        workflowId: v.string(),
+        awaitedEventName: v.string(),
+        sandboxId: v.string(),
         status: v.union(v.literal("pending"), v.literal("completed"), v.literal("failed"), v.literal("timedOut")),
         resultSummary: v.optional(v.string()),
         createdAt: v.number(),
@@ -329,39 +153,24 @@ export default defineSchema({
     sandboxCallbackDeliveries: defineTable({
         orgId: v.string(),
         sandboxRunId: v.id("sandboxRuns"),
-        deliveryId: v.string(), // caller-supplied, opaque, unique per attempt-family
-        outcome: v.union(v.literal("woke"), // first valid delivery for this id -- sendEvent fired
-        v.literal("duplicate")),
+        deliveryId: v.string(),
+        outcome: v.union(v.literal("woke"), v.literal("duplicate")),
         receivedAt: v.number(),
     })
         .index("by_org", ["orgId"])
         .index("by_org_delivery", ["orgId", "deliveryId"])
         .index("by_org_run", ["orgId", "sandboxRunId"]),
     sandboxCallbackDeadLetters: defineTable({
-        orgId: v.optional(v.string()), // absent when the payload itself couldn't be parsed
+        orgId: v.optional(v.string()),
         deliveryId: v.string(),
         reason: v.string(),
         rawBody: v.string(),
         createdAt: v.number(),
     }).index("by_org", ["orgId"]),
-    // ---------------------------------------------------------------------
-    // DELEGATION — an agent delegating to another agent uses THE SAME
-    // pause/wake system as the sandbox bridge: one system to maintain, not
-    // two. See engine/delegation.ts and engine/vpConnection.ts: every
-    // delegation/clone path terminates in exactly one call to this
-    // component's own public `engine/wakeup.enqueue`, never in a second
-    // onComplete/sendEvent path.
-    // ---------------------------------------------------------------------
-    // subagents — declared subagents, RECURSIVE (the child is a full
-    // `agents` row with its own aggregate). Isolation is by construction
-    // (eve.dev/docs/subagents: "inherits nothing from the root's authored
-    // slots") -- this table ONLY declares the parent->child link and exposes
-    // it as a named tool; it never copies a single field out of the child's
-    // own skills/connections/toolApprovals onto the parent.
     subagents: defineTable({
         orgId: v.string(),
         parentAgentId: v.id("agents"),
-        childAgentId: v.id("agents"), // full agent, own aggregate -- strict isolation
+        childAgentId: v.id("agents"),
         toolName: v.string(),
         description: v.optional(v.string()),
         enabled: v.boolean(),
@@ -370,16 +179,7 @@ export default defineSchema({
         .index("by_org", ["orgId"])
         .index("by_org_parent", ["orgId", "parentAgentId"])
         .index("by_org_child", ["orgId", "childAgentId"])
-        // Build-time collision guard (engine/delegation.declareSubagent):
-        // exact-match lookup of an existing (parent, toolName) pair, no filter().
         .index("by_org_parent_tool", ["orgId", "parentAgentId", "toolName"]),
-    // delegationRuns — one row per A->B delegation through a declared
-    // subagent (`subagents` table above). `workflowId`/`awaitedEventName` are
-    // the SAME two fields `engine/wakeup.enqueue` already threads through to
-    // `workflow.sendEvent` -- this table records WHICH delegation a given
-    // `wakeableWork` row belongs to; it never duplicates the wake mechanism
-    // itself (no second onComplete/sendEvent path exists anywhere in this
-    // engine).
     delegationRuns: defineTable({
         orgId: v.string(),
         parentAgentId: v.id("agents"),
@@ -396,17 +196,9 @@ export default defineSchema({
         .index("by_org_parent", ["orgId", "parentAgentId"])
         .index("by_org_workflow", ["orgId", "workflowId"])
         .index("by_org_awaitedEvent", ["orgId", "awaitedEventName"]),
-    // agentCloneRuns — the built-in `agent` tool (eve.dev/docs/subagents: "the
-    // built-in `agent` tool clones the ROOT, root-only, NOT recursive -- it
-    // cannot call itself"). `viaAgentTool` is the recursion guard: a clone
-    // invocation started BY a clone invocation (viaAgentTool: true passed in)
-    // is refused at `engine/delegation.invokeAgentClone` BEFORE any row here
-    // is written -- so every row in this table by construction has
-    // `viaAgentTool === false` on entry. Wakes through the SAME
-    // `engine/wakeup.enqueue` mechanism as `delegationRuns`.
     agentCloneRuns: defineTable({
         orgId: v.string(),
-        agentId: v.id("agents"), // the root being cloned
+        agentId: v.id("agents"),
         workflowId: v.string(),
         awaitedEventName: v.string(),
         status: v.union(v.literal("pending"), v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
@@ -416,14 +208,6 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"]),
-    // vpConnections — teamwork. The
-    // four VantagePeers tools (memory, tasks, messages, notes) wired as a
-    // CONNECTION of the agent aggregate, an intentional divergence from Eve. 0..1 row per agent;
-    // absence means "use the defaults" (all four ON) -- see
-    // `engine/vpConnection.ts:defaultToggles`. DIRECT access: invocation
-    // goes through a caller-supplied Convex function handle
-    // (`createFunctionHandle`, same discipline as `wakeableWork.workId` /
-    // `durableJobs.stepFunctionHandle`), never a `fetch()` call.
     vpConnections: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
@@ -436,9 +220,6 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"]),
-    // vpToolInvocations — audit trail of every VantagePeers tool call an
-    // agent made, ALWAYS written by `engine/vpConnection.invokeVpTool` in the
-    // SAME transaction family as the call itself.
     vpToolInvocations: defineTable({
         orgId: v.string(),
         agentId: v.id("agents"),
@@ -447,18 +228,124 @@ export default defineSchema({
     })
         .index("by_org", ["orgId"])
         .index("by_org_agent", ["orgId", "agentId"]),
-    // vpTenantFixture — TEST-ONLY stand-in for "VantagePeers' own tenant
-    // table" (component/testFixtures/vpTool.ts). This engine never owns
-    // VantagePeers' schema (component isolation) -- this fixture plays the
-    // CALLER-side function a real `vpFunctionHandle` would point to, so
-    // `component/engine/vpConnection.test.ts` can prove a VP tool write
-    // lands in the invoking agent's own org tenant (and that a mismatched
-    // orgId is refused) without needing a second real Convex deployment in
-    // the test harness. Not part of the public contract.
+    connections: defineTable({
+        orgId: v.string(),
+        agentId: v.id("agents"),
+        type: v.union(v.literal("mcp"), v.literal("openapi")),
+        name: v.string(),
+        serverConfig: v.string(),
+        authMode: v.union(v.literal("app-token"), v.literal("user-oauth"), v.literal("none"), v.literal("header")),
+        encryptedSecretCiphertext: v.optional(v.string()),
+        encryptedSecretIv: v.optional(v.string()),
+        status: v.union(v.literal("active"), v.literal("pending_authorization"), v.literal("error")),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_agent", ["orgId", "agentId"]),
+    connectionAuthorizations: defineTable({
+        orgId: v.string(),
+        connectionId: v.id("connections"),
+        workflowId: v.string(),
+        awaitedEventName: v.string(),
+        url: v.string(),
+        userCode: v.string(),
+        status: v.union(v.literal("pending"), v.literal("authorized"), v.literal("denied")),
+        resultSummary: v.optional(v.string()),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+        resolvedAt: v.optional(v.number()),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_connection", ["orgId", "connectionId"]),
     vpTenantFixture: defineTable({
         orgId: v.string(),
         tool: v.union(v.literal("memory"), v.literal("tasks"), v.literal("messages"), v.literal("notes")),
         argsJson: v.string(),
         createdAt: v.number(),
     }).index("by_org", ["orgId"]),
+    worldRuns: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        status: v.union(v.literal("running"), v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
+        eventCount: v.number(),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_run", ["orgId", "runId"]),
+    worldSteps: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        stepId: v.string(),
+        status: v.union(v.literal("running"), v.literal("completed"), v.literal("failed")),
+        dataJson: v.optional(v.string()),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org_run", ["orgId", "runId"])
+        .index("by_org_run_step", ["orgId", "runId", "stepId"]),
+    worldHooks: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        hookId: v.string(),
+        token: v.string(),
+        status: v.union(v.literal("pending"), v.literal("disposed")),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org_run", ["orgId", "runId"])
+        .index("by_org_hook", ["orgId", "hookId"])
+        .index("by_org_token", ["orgId", "token"]),
+    worldEvents: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        seq: v.number(),
+        eventType: v.string(),
+        stepId: v.optional(v.string()),
+        hookId: v.optional(v.string()),
+        correlationId: v.optional(v.string()),
+        dataJson: v.string(),
+        createdAt: v.number(),
+    })
+        .index("by_org_run", ["orgId", "runId"])
+        .index("by_org_run_seq", ["orgId", "runId", "seq"])
+        .index("by_org_correlation", ["orgId", "correlationId"]),
+    worldQueueMessages: defineTable({
+        orgId: v.string(),
+        queueName: v.string(),
+        messageId: v.string(),
+        payloadJson: v.string(),
+        idempotencyKey: v.optional(v.string()),
+        attempt: v.number(),
+        status: v.union(v.literal("pending"), v.literal("claimed"), v.literal("delivered"), v.literal("failed")),
+        deliverAt: v.number(),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_queue", ["orgId", "queueName"])
+        .index("by_org_message", ["orgId", "messageId"])
+        .index("by_org_queue_idempotencyKey", ["orgId", "queueName", "idempotencyKey"])
+        .index("by_org_queue_status_deliverAt", ["orgId", "queueName", "status", "deliverAt"]),
+    worldStreams: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        name: v.string(),
+        chunkCount: v.number(),
+        done: v.boolean(),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_run", ["orgId", "runId"])
+        .index("by_org_run_name", ["orgId", "runId", "name"]),
+    worldStreamChunks: defineTable({
+        orgId: v.string(),
+        runId: v.string(),
+        name: v.string(),
+        index: v.number(),
+        dataBase64: v.string(),
+        createdAt: v.number(),
+    }).index("by_org_run_name_index", ["orgId", "runId", "name", "index"]),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vantageos/agent-engine",
-  "version": "0.1.0-alpha.7",
+  "version": "0.3.0-alpha.0",
   "description": "Reusable Convex component: durable agent engine. Agent = data aggregate (root sheet + child tables), never compiled code. Built on @convex-dev/workflow + @convex-dev/workpool (+ @convex-dev/agent). Eve parity by design.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -19,6 +19,7 @@
   },
   "files": [
     "dist",
+    "!dist/component/testFixtures",
     "README.md",
     "LICENSE"
   ],
@@ -38,9 +39,15 @@
   },
   "scripts": {
     "dev": "convex dev",
-    "test": "vitest run",
+    "test": "npm run typecheck:build && npm run check:consumer-types && vitest run && npm run test:guard && npm run test:world-convex && npm run test:first-orchestrator",
+    "test:guard": "node --test evidence-skills/evals/guard.test.mjs",
+    "test:world-convex": "npm ci --prefix world-convex && npm test --prefix world-convex",
+    "test:first-orchestrator": "npm ci --prefix first-orchestrator && npm test --prefix first-orchestrator",
     "test:watch": "vitest",
+    "validate:agent-standard": "vitest run convex/lib/agentStandardValidator.test.ts",
     "typecheck": "tsc --noEmit",
+    "typecheck:build": "tsc -p tsconfig.build.json --noEmit",
+    "check:consumer-types": "node scripts/check-consumer-types.mjs",
     "build": "tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build && npm run check:public",
     "check:generated": "node scripts/check-generated-freshness.mjs",
@@ -55,6 +62,7 @@
     "@convex-dev/sharded-counter": "^0.2.1",
     "@convex-dev/workflow": "0.4.4",
     "@convex-dev/workpool": "0.4.7",
+    "@vantageos/cloud-identity": "0.21.3",
     "@vercel/sandbox": "^2.6.1",
     "ai": "6.0.35",
     "convex": "1.42.1",
@@ -62,8 +70,14 @@
   },
   "devDependencies": {
     "@edge-runtime/vm": "5.0.0",
+    "@types/node": "^26.1.2",
     "convex-test": "0.0.54",
     "typescript": "5.7.3",
-    "vitest": "2.1.9"
+    "vitest": "3.2.6"
+  },
+  "overrides": {
+    "nanoid": "^3.3.18",
+    "tinypool": "^2.1.2",
+    "vite": "^6.4.4"
   }
 }