@vantageos/agent-engine 0.1.0-alpha.8 → 0.3.0-alpha.1

package/dist/component/engine/delegation.js

@@ -2,46 +2,7 @@ import { v } from "convex/values";
 import { api, internal } from "../_generated/api.js";
 import { action, internalMutation, internalQuery, mutation, query, } from "../_generated/server.js";
 import { assertSameOrg, requireOrgId } from "../lib/auth.js";
-// engine/delegation — an agent delegating to another agent uses THE SAME
-// pause/wake system (awaitEvent/sendEvent) as the sandbox bridge: one
-// system to maintain, not two. Every delegation path below (declared
-// subagent AND the built-in `agent` clone tool) terminates in exactly ONE
-// call to `engine.wakeup.enqueue` -- the same public action this component
-// already ships, imported here and never reimplemented.
-// grep proof: this file makes zero calls to `wakeupPool.*` / `workflow.*`
-// directly; the only wake-capable call in this module is
-// `api.engine.wakeup.enqueue` at the bottom of `delegateToSubagent` and
-// `invokeAgentClone`.
-//
-// orgId discipline (component/lib/auth.ts): every PUBLIC function takes
-// `orgId` as an explicit ARGUMENT (auth does not propagate across a
-// component boundary), same as engine/mandates.ts / engine/wakeup.ts.
-// `delegateToSubagent`/`invokeAgentClone` are `action`s because they each
-// call `api.engine.wakeup.enqueue` (itself an action: the two-transaction
-// funding protocol) -- `orgId` is threaded explicitly through
-// every hop, never relying on any identity propagation across the boundary.
-// Reserved tool name for the built-in, root-only, non-recursive clone tool
-// (eve.dev/docs/subagents). A declared subagent may never claim this name --
-// that would silently shadow the built-in, which eve explicitly refuses to
-// do ("eve rejects the build rather than picking a winner").
 export const BUILTIN_AGENT_TOOL_NAME = "agent";
-// ---------------------------------------------------------------------
-// (a.1) DECLARED SUBAGENTS -- strict isolation, build-time collision guard
-// ---------------------------------------------------------------------
-// declareSubagent — registers a declared subagent as a NAMED tool on the
-// parent. Isolation is by construction: this mutation writes ONLY the
-// parent->child link + toolName; it never copies a single field out of the
-// child's own `skills`/`connections`/`toolApprovals` rows onto the parent,
-// and never will -- a declared subagent's own aggregate is the ONLY place
-// its slots ever live (eve.dev/docs/subagents, verbatim: "a declared
-// subagent inherits nothing from the root's authored slots").
-//
-// BUILD-TIME COLLISION GUARD: `toolName` must be unique among (1) the
-// reserved built-in `agent` tool name, (2) every OTHER declared subagent of
-// this same parent, and (3) every `toolApprovals` row already registered
-// for this parent (a toolApprovals row is how this engine represents "a
-// named tool this agent already exposes"). Any collision REJECTS the
-// mutation -- the row is never written, there is no silent "last one wins".
 export const declareSubagent = mutation({
     args: {
         orgId: v.string(),
@@ -119,18 +80,6 @@ export const listSubagents = query({
             .collect();
     },
 });
-// ---------------------------------------------------------------------
-// (a.2) DELEGATION -- reuses `engine.wakeup.enqueue` end to end
-// ---------------------------------------------------------------------
-// delegateToSubagent — A delegates to a declared subagent B by the SAME
-// pause/wake mechanism the sandbox bridge uses: it enqueues the
-// caller-supplied `workFunctionHandle` (an action that performs B's turn)
-// through `api.engine.wakeup.enqueue`. That enqueue funds through
-// `mandates.spendInternal` (the funding choke point, untouched), puts the work
-// into `wakeupPool`, and when it resolves, `engine.wakeup.onWorkComplete`
-// calls `workflow.sendEvent` (workflowId, awaitedEventName, ...) -- waking
-// whatever workflow step A's own session parked on `step.awaitEvent`. There
-// is no second onComplete/sendEvent path anywhere in this file.
 export const delegateToSubagent = action({
     args: {
         orgId: v.string(),
@@ -164,10 +113,6 @@ export const delegateToSubagent = action({
             workflowId: args.workflowId,
             awaitedEventName: args.awaitedEventName,
         });
-        // THE reuse point: no bespoke pause/wake code below this line -- this
-        // is a direct call into this component's own PUBLIC `engine.wakeup.enqueue`
-        // action. `orgId` is threaded explicitly (no identity propagation
-        // across the component boundary).
         await ctx.runAction(api.engine.wakeup.enqueue, {
             orgId,
             agentId: subagent.childAgentId,
@@ -182,19 +127,6 @@ export const delegateToSubagent = action({
         return delegationRunId;
     },
 });
-// ---------------------------------------------------------------------
-// (a.3) BUILT-IN `agent` TOOL -- root-only clone, NOT recursive
-// ---------------------------------------------------------------------
-// invokeAgentClone — the built-in `agent` tool (eve.dev/docs/subagents): a
-// clone of the ROOT agent, invocable by the root itself, but the clone
-// CANNOT call itself again. `viaAgentTool` is the recursion guard: the
-// root's own first call always passes `viaAgentTool: false` (or omits it).
-// Anything invoking this action must set `viaAgentTool: true` on any call
-// made FROM INSIDE a clone's own work -- and that is exactly the value this
-// handler refuses. There is no code path in this engine that can reach the
-// pool a second time for the same clone chain: the guard runs BEFORE
-// `wakeup.enqueue` is ever called, so a recursive attempt never enters the
-// workpool at all.
 export const invokeAgentClone = action({
     args: {
         orgId: v.string(),
@@ -229,8 +161,6 @@ export const invokeAgentClone = action({
             workflowId: args.workflowId,
             awaitedEventName: args.awaitedEventName,
         });
-        // Same reuse point as `delegateToSubagent`: one call into the SAME
-        // public `engine.wakeup.enqueue`, nothing bespoke.
         await ctx.runAction(api.engine.wakeup.enqueue, {
             orgId,
             agentId: args.agentId,
@@ -245,10 +175,6 @@ export const invokeAgentClone = action({
         return cloneRunId;
     },
 });
-// ---------------------------------------------------------------------
-// INTERNAL helpers -- unreachable from any client, same discipline as
-// `engine/wakeup.enqueueInternal`.
-// ---------------------------------------------------------------------
 export const getSubagentInternal = internalQuery({
     args: { orgId: v.string(), subagentId: v.id("subagents") },
     returns: v.union(v.object({

package/dist/component/engine/directory.js

@@ -1,24 +1,6 @@
 import { v } from "convex/values";
 import { query } from "../_generated/server.js";
 import { requireOrgId } from "../lib/auth.js";
-// engine/directory — component-boundary port of the app-level
-// `convex/directory.ts:listByOrg`.
-//
-// Trust-boundary divergence from the app-level prototype (see
-// component/lib/auth.ts): auth does NOT propagate across a component
-// boundary, so `orgId` is a caller-supplied ARGUMENT here (deny by default
-// via `requireOrgId(args.orgId)`), never read from `ctx.auth`. The consumer
-// app has already authenticated its user and resolved orgId on its own
-// side before calling in.
-//
-// Shape divergence: the app-level prototype also reports
-// `subagentCount`/`connectionCount` by joining the `subagents` and
-// `connections` tables. Those tables are NOT (yet) re-hosted inside this
-// component boundary (see component/schema.ts SCOPE note) -- porting a
-// join against tables this component does not own would violate component
-// isolation. `listByOrg` here therefore returns only what this component's
-// own `agents` table can answer; counts can be added once `subagents`/
-// `connections` gain their own component-level test harness.
 export const listByOrg = query({
     args: { orgId: v.string() },
     returns: v.array(v.object({

package/dist/component/engine/durableJob.d.ts

@@ -1,17 +1,18 @@
 import { WorkflowManager, type WorkflowId } from "@convex-dev/workflow";
+type JobRunStatus = "running" | "completed" | "abandoned" | "cancelled";
 export declare const workflow: WorkflowManager;
 export declare const start: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
+    kind: string;
     stepFunctionHandle: string;
     totalSteps: number;
     maxAttemptsPerStep: number;
-    kind: string;
-}, Promise<import("convex/values").GenericId<"durableJobs">>>;
+}, Promise<string>>;
 export declare const getStatus: import("convex/server").RegisteredQuery<"public", {
     orgId: string;
-    jobId: import("convex/values").GenericId<"durableJobs">;
+    jobId: string;
 }, Promise<{
-    status: "running" | "completed" | "abandoned" | "cancelled";
+    status: JobRunStatus;
     cursor: number;
     totalSteps: number;
     lastError: string | undefined;
@@ -19,28 +20,34 @@ export declare const getStatus: import("convex/server").RegisteredQuery<"public"
 }>>;
 export declare const cancel: import("convex/server").RegisteredMutation<"public", {
     orgId: string;
-    jobId: import("convex/values").GenericId<"durableJobs">;
+    jobId: string;
 }, Promise<null>>;
-export declare const getJobInternal: import("convex/server").RegisteredQuery<"internal", {
-    jobId: import("convex/values").GenericId<"durableJobs">;
+export declare const getJobInternalV2: import("convex/server").RegisteredQuery<"internal", {
+    orgId: string;
+    runId: string;
 }, Promise<{
     cursor: number;
     totalSteps: number;
     maxAttemptsPerStep: number;
-    status: "running" | "completed" | "abandoned" | "cancelled";
+    status: JobRunStatus;
 } | null>>;
-export declare const runStepInternal: import("convex/server").RegisteredMutation<"internal", {
-    jobId: import("convex/values").GenericId<"durableJobs">;
+export declare const runStepInternalV2: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    runId: string;
     stepIndex: number;
 }, Promise<null>>;
-export declare const markAbandonedInternal: import("convex/server").RegisteredMutation<"internal", {
-    jobId: import("convex/values").GenericId<"durableJobs">;
-    stepIndex: number;
+export declare const markAbandonedInternalV2: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    runId: string;
     error: string;
+    stepIndex: number;
 }, Promise<null>>;
-export declare const markCompletedInternal: import("convex/server").RegisteredMutation<"internal", {
-    jobId: import("convex/values").GenericId<"durableJobs">;
+export declare const markCompletedInternalV2: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    runId: string;
 }, Promise<null>>;
-export declare const durableJobWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
-    jobId: import("convex/values").VId<import("convex/values").GenericId<"durableJobs">, "required">;
+export declare const durableJobWorkflowV2: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
+    orgId: import("convex/values").VString<string, "required">;
+    runId: import("convex/values").VString<string, "required">;
 }>, WorkflowId>;
+export {};

package/dist/component/engine/durableJob.js

@@ -2,52 +2,38 @@ import { v } from "convex/values";
 import { WorkflowManager } from "@convex-dev/workflow";
 import { components, internal } from "../_generated/api.js";
 import { internalMutation, internalQuery, mutation, query, } from "../_generated/server.js";
-import { assertSameOrg, requireOrgId } from "../lib/auth.js";
-// durableJobs — THE SURVIVAL CONTRACT: pause at the step boundary,
-// deterministic replay, resume, and abandon after N failures. This ENVELOPS
-// `@convex-dev/workflow` -- it does not reimplement
-// durable execution. Every real unit of work (the caller-supplied
-// `stepFunctionHandle`) runs inside its own bounded mutation call; the
-// workflow persists `cursor` (steps [0, cursor) done) between calls, so a
-// job whose TOTAL wall-clock time exceeds a single Convex action's ceiling
-// still completes -- no single call has to survive past the ceiling, only
-// the aggregate progress does.
-//
-// Contract surface (this is what a consumer calls; see
-// examples/vantage-peers-long-task for a worked integration):
-//   1. `start`      -- enqueue a job of N steps, driven by a step function
-//                       the CALLER owns (created via `createFunctionHandle`
-//                       in the caller's own app). We never read the
-//                       caller's tables directly -- component isolation.
-//   2. `getStatus`  -- poll status/cursor/lastError/abandonedAtStep.
-//   3. `cancel`     -- best-effort stop (checked at the next step boundary
-//                       and by the workflow's own cancel()).
-//   4. (internal) the workflow itself is the pause/resume/replay engine:
-//       - PAUSE AT STEP BOUNDARY: each loop iteration is one workflow step;
-//         `@convex-dev/workflow` durably persists after each step returns,
-//         so the process can die between any two steps with zero data loss.
-//       - DETERMINISTIC REPLAY: `runStepInternal` is idempotent -- it
-//         no-ops for any stepIndex < job.cursor, so replaying the workflow
-//         handler after a resume never re-runs completed work.
-//       - RESUME: on restart, the workflow replays its journal up to the
-//         last completed step then continues the same in-memory loop; our
-//         `cursor` on the `durableJobs` row is the second, redundant source
-//         of truth a caller can poll without touching workflow internals.
-//       - ABANDON AFTER N: `runStepInternal` retries the caller's step
-//         function up to `maxAttemptsPerStep` times INSIDE one workflow
-//         step (not via workflow-level retry, which does not apply to
-//         mutations); only once attempts are exhausted does the step throw,
-//         which the workflow handler catches and turns into
-//         `status: "abandoned"` with `abandonedAtStep` + `lastError`.
-//
-// Versioned workflow discipline (workflow#35) -- same as
-// `engine/workflows.ts:sessionWorkflowV1`: never edit `durableJobWorkflowV1`
-// in place once jobs reference it; ship `...V2` and drain v1 first.
-const CURRENT_WORKFLOW_VERSION = "v1";
+import { requireOrgId } from "../lib/auth.js";
+import { appendEventCore, bindWorkflowToRun, loadRun, openRun, workflowOfRun, } from "./world.js";
+const CURRENT_WORKFLOW_VERSION = "v2";
+async function readJob(ctx, orgId, runId, notFoundMessage = "Job not found") {
+    const run = await loadRun(ctx, orgId, runId, "job", notFoundMessage);
+    const num = (field) => {
+        const value = run.created[field];
+        if (typeof value !== "number") {
+            throw new Error(`Job run_created payload is missing ${field}`);
+        }
+        return value;
+    };
+    const stepHandle = run.created.stepFunctionHandle;
+    if (typeof stepHandle !== "string") {
+        throw new Error("Job run_created payload is missing stepFunctionHandle");
+    }
+    const steps = await ctx.db
+        .query("worldSteps")
+        .withIndex("by_org_run", (q) => q.eq("orgId", orgId).eq("runId", runId))
+        .collect();
+    return {
+        run,
+        totalSteps: num("totalSteps"),
+        maxAttemptsPerStep: num("maxAttemptsPerStep"),
+        stepFunctionHandle: stepHandle,
+        cursor: steps.filter((s) => s.status === "completed").length,
+    };
+}
+function publicStatus(status) {
+    return status === "failed" ? "abandoned" : status;
+}
 export const workflow = new WorkflowManager(components.workflow);
-// ---------------------------------------------------------------------
-// PUBLIC CONTRACT
-// ---------------------------------------------------------------------
 export const start = mutation({
     args: {
         orgId: v.string(),
@@ -56,7 +42,7 @@ export const start = mutation({
         totalSteps: v.number(),
         maxAttemptsPerStep: v.number(),
     },
-    returns: v.id("durableJobs"),
+    returns: v.string(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
         if (!Number.isInteger(args.totalSteps) || args.totalSteps <= 0) {
@@ -69,26 +55,29 @@ export const start = mutation({
         if (args.stepFunctionHandle.length === 0) {
             throw new Error("Validation: stepFunctionHandle must not be empty");
         }
-        const now = Date.now();
-        const jobId = await ctx.db.insert("durableJobs", {
+        const runId = await openRun(ctx, {
+            orgId,
+            kind: "job",
+            data: {
+                kind: args.kind,
+                stepFunctionHandle: args.stepFunctionHandle,
+                totalSteps: args.totalSteps,
+                maxAttemptsPerStep: args.maxAttemptsPerStep,
+                workflowVersion: CURRENT_WORKFLOW_VERSION,
+            },
+        });
+        const workflowId = await workflow.start(ctx, internal.engine.durableJob.durableJobWorkflowV2, { orgId, runId });
+        await bindWorkflowToRun(ctx, {
             orgId,
-            kind: args.kind,
-            stepFunctionHandle: args.stepFunctionHandle,
-            totalSteps: args.totalSteps,
-            maxAttemptsPerStep: args.maxAttemptsPerStep,
-            cursor: 0,
-            status: "running",
+            runId,
+            workflowId,
             workflowVersion: CURRENT_WORKFLOW_VERSION,
-            createdAt: now,
-            updatedAt: now,
         });
-        const workflowId = await workflow.start(ctx, internal.engine.durableJob.durableJobWorkflowV1, { jobId });
-        await ctx.db.patch(jobId, { workflowId });
-        return jobId;
+        return runId;
     },
 });
 export const getStatus = query({
-    args: { orgId: v.string(), jobId: v.id("durableJobs") },
+    args: { orgId: v.string(), jobId: v.string() },
     returns: v.object({
         status: v.union(v.literal("running"), v.literal("completed"), v.literal("abandoned"), v.literal("cancelled")),
         cursor: v.number(),
@@ -98,44 +87,61 @@ export const getStatus = query({
     }),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const job = await ctx.db.get(args.jobId);
-        assertSameOrg(orgId, job, "Job not found");
+        const job = await readJob(ctx, orgId, args.jobId);
+        const status = publicStatus(job.run.status);
+        let lastError;
+        let abandonedAtStep;
+        if (job.run.status === "failed") {
+            const journal = await ctx.db
+                .query("worldEvents")
+                .withIndex("by_org_run_seq", (q) => q.eq("orgId", orgId).eq("runId", job.run.runId))
+                .collect();
+            const failed = [...journal].reverse().find((e) => e.eventType === "run_failed");
+            if (failed) {
+                try {
+                    const data = JSON.parse(failed.dataJson);
+                    if (typeof data.lastError === "string")
+                        lastError = data.lastError;
+                    if (typeof data.abandonedAtStep === "number") {
+                        abandonedAtStep = data.abandonedAtStep;
+                    }
+                }
+                catch {
+                }
+            }
+        }
         return {
-            status: job.status,
+            status,
             cursor: job.cursor,
             totalSteps: job.totalSteps,
-            lastError: job.lastError,
-            abandonedAtStep: job.abandonedAtStep,
+            lastError,
+            abandonedAtStep,
         };
     },
 });
 export const cancel = mutation({
-    args: { orgId: v.string(), jobId: v.id("durableJobs") },
+    args: { orgId: v.string(), jobId: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
         const orgId = requireOrgId(args.orgId);
-        const job = await ctx.db.get(args.jobId);
-        assertSameOrg(orgId, job, "Job not found");
-        if (job.status !== "running")
+        const run = await loadRun(ctx, orgId, args.jobId, "job", "Job not found");
+        if (run.status !== "running")
             return null;
-        await ctx.db.patch(args.jobId, {
-            status: "cancelled",
-            updatedAt: Date.now(),
+        await appendEventCore(ctx, {
+            orgId,
+            runId: run.runId,
+            eventType: "run_cancelled",
+            dataJson: "{}",
         });
-        if (job.workflowId) {
-            await workflow.cancel(ctx, job.workflowId);
+        const bound = await workflowOfRun(ctx, orgId, run.runId);
+        if (bound !== null) {
+            await workflow.cancel(ctx, bound.workflowId);
         }
         return null;
     },
 });
-// ---------------------------------------------------------------------
-// INTERNAL — server-to-server only, invoked by the workflow's own steps.
-// The workflow runs with no end-user identity: every handler below scopes
-// strictly by the orgId already recorded on the `durableJobs` row, never a
-// client-supplied one.
-// ---------------------------------------------------------------------
-export const getJobInternal = internalQuery({
-    args: { jobId: v.id("durableJobs") },
+export const getJobInternalV2 = internalQuery({
+    args: { orgId: v.string(), runId: v.string() },
     returns: v.union(v.object({
         cursor: v.number(),
         totalSteps: v.number(),
@@ -143,43 +149,59 @@ export const getJobInternal = internalQuery({
         status: v.union(v.literal("running"), v.literal("completed"), v.literal("abandoned"), v.literal("cancelled")),
     }), v.null()),
     handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job)
+        const run = await ctx.db
+            .query("worldRuns")
+            .withIndex("by_org_run", (q) => q.eq("orgId", args.orgId).eq("runId", args.runId))
+            .unique();
+        if (!run)
             return null;
+        const job = await readJob(ctx, args.orgId, args.runId);
         return {
             cursor: job.cursor,
             totalSteps: job.totalSteps,
             maxAttemptsPerStep: job.maxAttemptsPerStep,
-            status: job.status,
+            status: publicStatus(job.run.status),
         };
     },
 });
-// The one real unit of work per step-boundary. DETERMINISTIC REPLAY GUARD:
-// no-ops for any stepIndex already covered by job.cursor, so a workflow
-// resume (journal replay after a kill mid-run) never re-executes the
-// caller's step function for completed steps. ABANDON AFTER N: retries the
-// caller's step function up to `maxAttemptsPerStep` times before throwing
-// (throwing is what the workflow handler below turns into "abandoned").
-export const runStepInternal = internalMutation({
-    args: { jobId: v.id("durableJobs"), stepIndex: v.number() },
+export const runStepInternalV2 = internalMutation({
+    args: { orgId: v.string(), runId: v.string(), stepIndex: v.number() },
     returns: v.null(),
     handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job)
-            throw new Error("Job not found");
-        if (job.status === "cancelled")
+        const job = await readJob(ctx, args.orgId, args.runId);
+        if (job.run.status === "cancelled")
             return null;
-        if (args.stepIndex < job.cursor) {
-            // Already-completed step replayed by a resumed workflow -- no-op.
+        const stepId = String(args.stepIndex);
+        const existing = await ctx.db
+            .query("worldSteps")
+            .withIndex("by_org_run_step", (q) => q.eq("orgId", args.orgId).eq("runId", args.runId).eq("stepId", stepId))
+            .unique();
+        if (existing?.status === "completed")
             return null;
-        }
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "step_created",
+            stepId,
+            dataJson: "{}",
+        });
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "step_started",
+            stepId,
+            dataJson: "{}",
+        });
         let lastError;
         for (let attempt = 1; attempt <= job.maxAttemptsPerStep; attempt++) {
             try {
-                await ctx.runMutation(job.stepFunctionHandle, { orgId: job.orgId, jobId: args.jobId, stepIndex: args.stepIndex });
-                await ctx.db.patch(args.jobId, {
-                    cursor: args.stepIndex + 1,
-                    updatedAt: Date.now(),
+                await ctx.runMutation(job.stepFunctionHandle, { orgId: args.orgId, jobId: args.runId, stepIndex: args.stepIndex });
+                await appendEventCore(ctx, {
+                    orgId: args.orgId,
+                    runId: args.runId,
+                    eventType: "step_completed",
+                    stepId,
+                    dataJson: JSON.stringify({ attempt }),
                 });
                 return null;
             }
@@ -192,71 +214,93 @@ export const runStepInternal = internalMutation({
             : new Error(String(lastError));
     },
 });
-export const markAbandonedInternal = internalMutation({
-    args: { jobId: v.id("durableJobs"), stepIndex: v.number(), error: v.string() },
+export const markAbandonedInternalV2 = internalMutation({
+    args: {
+        orgId: v.string(),
+        runId: v.string(),
+        stepIndex: v.number(),
+        error: v.string(),
+    },
     returns: v.null(),
     handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job || job.status !== "running")
+        const job = await readJob(ctx, args.orgId, args.runId);
+        if (job.run.status !== "running")
             return null;
-        await ctx.db.patch(args.jobId, {
-            status: "abandoned",
-            abandonedAtStep: args.stepIndex,
-            lastError: args.error,
-            updatedAt: Date.now(),
+        const stepId = String(args.stepIndex);
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "step_created",
+            stepId,
+            dataJson: "{}",
+        });
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "step_failed",
+            stepId,
+            dataJson: JSON.stringify({ error: args.error }),
+        });
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "run_failed",
+            dataJson: JSON.stringify({
+                reason: "abandoned",
+                abandonedAtStep: args.stepIndex,
+                lastError: args.error,
+            }),
         });
         return null;
     },
 });
-export const markCompletedInternal = internalMutation({
-    args: { jobId: v.id("durableJobs") },
+export const markCompletedInternalV2 = internalMutation({
+    args: { orgId: v.string(), runId: v.string() },
     returns: v.null(),
     handler: async (ctx, args) => {
-        const job = await ctx.db.get(args.jobId);
-        if (!job || job.status !== "running")
+        const job = await readJob(ctx, args.orgId, args.runId);
+        if (job.run.status !== "running")
             return null;
-        await ctx.db.patch(args.jobId, {
-            status: "completed",
-            updatedAt: Date.now(),
+        await appendEventCore(ctx, {
+            orgId: args.orgId,
+            runId: args.runId,
+            eventType: "run_completed",
+            dataJson: "{}",
         });
         return null;
     },
 });
-// durableJobWorkflowV1 -- the pause/resume/replay engine. One loop
-// iteration == one workflow step == one durability boundary: `step.
-// runMutation` returns only after `@convex-dev/workflow` has persisted the
-// journal entry, so a process kill between any two iterations loses zero
-// progress. On resume the workflow replays already-journaled steps from
-// its own history (no caller-visible effect, since runStepInternal is
-// idempotent below job.cursor) and continues the loop from where it left
-// off.
-export const durableJobWorkflowV1 = workflow.define({
-    args: { jobId: v.id("durableJobs") },
+export const durableJobWorkflowV2 = workflow.define({
+    args: { orgId: v.string(), runId: v.string() },
     returns: v.null(),
     handler: async (step, args) => {
-        const job = await step.runQuery(internal.engine.durableJob.getJobInternal, {
-            jobId: args.jobId,
+        const job = await step.runQuery(internal.engine.durableJob.getJobInternalV2, {
+            orgId: args.orgId,
+            runId: args.runId,
         });
         if (!job || job.status !== "running")
             return null;
         for (let i = job.cursor; i < job.totalSteps; i++) {
             try {
-                await step.runMutation(internal.engine.durableJob.runStepInternal, {
-                    jobId: args.jobId,
+                await step.runMutation(internal.engine.durableJob.runStepInternalV2, {
+                    orgId: args.orgId,
+                    runId: args.runId,
                     stepIndex: i,
                 });
             }
             catch (err) {
-                await step.runMutation(internal.engine.durableJob.markAbandonedInternal, {
-                    jobId: args.jobId,
+                await step.runMutation(internal.engine.durableJob.markAbandonedInternalV2, {
+                    orgId: args.orgId,
+                    runId: args.runId,
                     stepIndex: i,
                     error: err instanceof Error ? err.message : String(err),
                 });
                 return null;
             }
         }
-        await step.runMutation(internal.engine.durableJob.markCompletedInternal, {
-            jobId: args.jobId,
+        await step.runMutation(internal.engine.durableJob.markCompletedInternalV2, {
+            orgId: args.orgId,
+            runId: args.runId,
         });
         return null;
     },