@vantageos/agent-engine 0.1.0-alpha.1 → 0.1.0-alpha.2

package/README.md

@@ -215,16 +215,21 @@ that all contributors run) is Pi's to make, not this PR's.
   interruption); a step that always fails is retried and the job is
   `abandoned` (never touching the next step); a step that fails once then
   succeeds still reaches `completed`; cross-org `getStatus` is denied.
+- `component/durableJob.componentPackaging.test.ts` — the SAME contract
+  (long job survives, abandon-after-N, org isolation, cancel), but run
+  against `component/_generated/api` — the exact source tree compiled to
+  `dist/component/` and published — proving the migrated, packaged code
+  itself, not only the repo-root dev app.
 
 Run: `npx vitest run` (or `npm test`).
 
-## Packaging & publication (T2-TER)
+## Packaging & publication (T2-TER, functions since T2-QUATER)
 
 `@vantageos/agent-engine` is published to npm under the `alpha` dist-tag
 (`npm view @vantageos/agent-engine version` / `dist-tags`, read from the
 registry after publish, never from `npm publish`'s own exit status). The
 package exposes a resolvable `"./convex.config"` subpath (types + JS,
-built by `npm run build` from `convex/component/convex.config.ts` via
+built by `npm run build` from `component/convex.config.ts` via
 `tsc -p tsconfig.build.json` into `dist/component/`), so a consumer's
 `convex/convex.config.ts` can do:
 
@@ -237,21 +242,71 @@ app.use(agentEngine);
 export default app;
 ```
 
-**Known remaining gap, stated here where it is read (not only in a
-message):** `convex/component/convex.config.ts` currently declares only
-the component's identity (`defineComponent("agentEngine")`) and its
-sub-component composition (workflow + 2 workpools + agent). It does not
-yet re-host this repo's schema/functions (`convex/schema.ts`,
-`convex/agents.ts`, `convex/skills.ts`, `convex/engine/**`) inside the
-component boundary, so `components.agentEngine.engine.durableJob.*` etc.
-are not yet callable from a consumer through the published component --
-see `examples/vantage-peers-long-task/README.md` "Packaging note" for the
-full detail and exactly what remains.
+### What's callable, and what isn't (read this before wiring a consumer)
+
+Since T2-QUATER, `component/` (sibling of `convex/`, NOT nested under it —
+see "Why `component/` and not `convex/component/`" below) hosts the
+**actual, compiled, published functions** for a real slice of the engine,
+not just the component's identity:
+
+- `component/schema.ts` — the `durableJobs` table (+ a test-only
+  `callerStepInvocations` fixture table).
+- `component/engine/durableJob.ts` — `start` / `getStatus` / `cancel`
+  (public contract) + `durableJobWorkflowV1` (the versioned pause/resume/
+  replay workflow) + its internal step-runner mutations.
+- `component/lib/auth.ts` — `requireOrgId` / `assertSameOrg`: orgId is
+  derived server-side and is the first field of every index; deny by
+  default travels WITH the component, not just with this repo's own app.
+
+**Callable through the published component today:**
+`components.agentEngine.engine.durableJob.start(...)`,
+`.getStatus(...)`, `.cancel(...)` — verified two ways: (1)
+`component/durableJob.componentPackaging.test.ts` runs `convex-test`
+directly against `component/_generated/api` (the exact source tree
+`tsc -p tsconfig.build.json` compiles into `dist/component/`, which is
+what `npm pack` ships), so the compiled artifact has a real green test
+suite behind it, not just the repo-root dev app's; (2) a from-scratch
+consumer probe (install the published tarball into a bare `npx convex
+dev` project, register the component, call `durableJob.start` +
+`getStatus` from the consumer's own function) — see the T2-QUATER
+completion report for the verbatim transcript.
+
+**NOT yet callable through the published component** (still only exists
+in this repo's OWN dev/test deployment under `convex/schema.ts` +
+`convex/agents.ts` + `convex/skills.ts`, used by `npx convex dev` and the
+repo-root `convex-test` suite): the agent aggregate itself — `agents`,
+`skills`, `subagents`, `connections`, `habits`, `sandboxConfig`,
+`toolApprovals`, `modelKeys` — and the rest of the durable-session engine
+— `sessions`, `sessionEvents`, `awaitEventTimeouts`, `wakeableWork`,
+`engine/wakeup.ts`, `engine/resolvers.ts`, `engine/workflows.ts`
+(`sessionWorkflowV1`). Porting each of those under `component/` without a
+working component-level `convex-test` harness behind it would ship
+unverified code — Day 128 forbids that; it is deliberately left for the
+next, separately-scoped migration.
+
+### Why `component/` and not `convex/component/`
+
+`npx convex codegen --component-dir <path>` builds a synthetic root app
+that does `import component from "<relative-import-to-path>"`. When
+`<path>` is nested INSIDE the functions directory it resolves from
+(`convex/`), that relative import comes out as a bare specifier with no
+leading `./` or `../` (e.g. `"component/convex.config.js"`), which esbuild
+correctly refuses to resolve as a relative path — not a bug in our code,
+a corner case of running `--component-dir` against a directory nested
+under the default functions directory. Moving the component's source tree
+one level up, to `component/` (a sibling of `convex/`, mirroring how
+`@convex-dev/workflow` itself keeps its component source under `src/component`,
+outside its `example/convex` app directory) makes the generated relative
+import start with `../`, which resolves — measured empirically against
+this exact repo layout, not guessed.
 
 ## Status
 
 T1 (schema + durable session engine, PR #1) merged @
 `9f3401ba63e6e663af95e9e4f5da42bc30b3550b`. I1 (long-task survival
 contract, `engine/durableJob.ts`) — not merged, Eta reviews, merge on Pi
-token. T2-TER (this PR, npm packaging + component identity + publication)
-— see "Packaging & publication" above; **not merged**.
+token. T2-TER (npm packaging + component identity + publication) and
+T2-QUATER (this pass: migrated `durableJob` + its schema + `lib/auth.ts`
+under the actual component boundary, `component/`, with its own
+`_generated/` and its own green `convex-test` suite) — see "Packaging &
+publication" above; **not merged**.

package/dist/component/_generated/api.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as engine_durableJob from "../engine/durableJob.js";
+import type * as lib_auth from "../lib/auth.js";
+import type * as testFixtures_callerSteps from "../testFixtures/callerSteps.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    "engine/durableJob": typeof engine_durableJob;
+    "lib/auth": typeof lib_auth;
+    "testFixtures/callerSteps": typeof testFixtures_callerSteps;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {
+    workflow: import("@convex-dev/workflow/_generated/component.js").ComponentApi<"workflow">;
+    agentTurnPool: import("@convex-dev/workpool/_generated/component.js").ComponentApi<"agentTurnPool">;
+    wakeupPool: import("@convex-dev/workpool/_generated/component.js").ComponentApi<"wakeupPool">;
+    agent: import("@convex-dev/agent/_generated/component.js").ComponentApi<"agent">;
+};
+export {};

package/dist/component/_generated/api.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();

package/dist/component/_generated/component.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { FunctionReference } from "convex/server";
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+    engine: {
+        durableJob: {
+            cancel: FunctionReference<"mutation", "internal", {
+                jobId: string;
+            }, null, Name>;
+            getStatus: FunctionReference<"query", "internal", {
+                jobId: string;
+            }, {
+                abandonedAtStep?: number;
+                cursor: number;
+                lastError?: string;
+                status: "running" | "completed" | "abandoned" | "cancelled";
+                totalSteps: number;
+            }, Name>;
+            start: FunctionReference<"mutation", "internal", {
+                kind: string;
+                maxAttemptsPerStep: number;
+                stepFunctionHandle: string;
+                totalSteps: number;
+            }, string, Name>;
+        };
+    };
+};

package/dist/component/_generated/component.js

@@ -0,0 +1,10 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+export {};

package/dist/component/_generated/dataModel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/dist/component/_generated/dataModel.js

@@ -0,0 +1,10 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+export {};

package/dist/component/_generated/server.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
+import type { DataModel } from "./dataModel.js";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/dist/component/_generated/server.js

@@ -0,0 +1,77 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { actionGeneric, httpActionGeneric, queryGeneric, mutationGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, } from "convex/server";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;

package/dist/component/convex.config.js

@@ -12,28 +12,26 @@ import agent from "@convex-dev/agent/convex.config";
 //   import agentEngine from "@vantageos/agent-engine/convex.config";
 //   app.use(agentEngine);
 //
-// NOTRE LIGNE / KNOWN GAP (say it here, at the point of read, not only in
-// a message — T2-TER instruction): this file declares agent-engine's
-// COMPONENT IDENTITY and its sub-component composition
-// (workflow + 2 named workpools + agent), which is exactly what makes the
-// `@vantageos/agent-engine/convex.config` import RESOLVE for a consumer
-// and what makes `app.use(agentEngine)` build without throwing.
+// This file declares agent-engine's COMPONENT IDENTITY and its
+// sub-component composition (workflow + 2 named workpools + agent), which
+// is what makes the `@vantageos/agent-engine/convex.config` import
+// RESOLVE for a consumer and what makes `app.use(agentEngine)` build
+// without throwing.
 //
-// It does NOT yet re-host this repo's schema (convex/schema.ts) and
-// functions (convex/agents.ts, convex/skills.ts, convex/engine/**) inside
-// this component boundary, so a consumer cannot yet call
-// `components.agentEngine.agents.create` / `components.agentEngine.engine
-// .durableJob.start` etc. through the published component -- those
-// functions still only exist in this repo's OWN dev/test deployment
-// (convex/convex.config.ts, defineApp, used by `npx convex dev` and
-// convex-test). That migration (moving schema.ts + agents.ts + skills.ts +
-// engine/** under convex/component/, regenerating this component's OWN
-// convex/component/_generated/ against a real component-hosting
-// deployment, and re-verifying every existing test) is real, non-trivial
-// work that was NOT attempted in this packaging pass -- doing it
-// unverified would have violated Day 128 (never weaken/bypass a test to
-// make it pass) by shipping schema/function code with no working
-// convex-test harness behind it. It is the next, separately-scoped task.
+// T2-QUATER (this pass): `convex/component/engine/durableJob.ts` +
+// `convex/component/schema.ts` (its `durableJobs` table) +
+// `convex/component/lib/auth.ts` (orgId isolation) are now CO-LOCATED in
+// this same directory tree, alongside this file — this is what a
+// consumer's `npx convex dev`/`deploy` actually bundles and deploys under
+// the component boundary, and what makes
+// `components.agentEngine.engine.durableJob.start(...)` resolve to a real
+// function instead of `undefined`. See README.md "What's callable" for
+// the exact, current boundary: durableJob is IN; the rest of the agent
+// aggregate (agents, skills, subagents, connections, habits,
+// sandboxConfig, toolApprovals, modelKeys, sessions, sessionEvents,
+// awaitEventTimeouts, wakeableWork) is deliberately NOT yet re-hosted
+// here — porting those without a working component-level test harness
+// behind each of them would violate Day 128 (never ship unverified).
 const component = defineComponent("agentEngine");
 component.use(workflow);
 component.use(workpool, { name: "agentTurnPool" });

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

@@ -0,0 +1,43 @@
+import { WorkflowManager, type WorkflowId } from "@convex-dev/workflow";
+export declare const workflow: WorkflowManager;
+export declare const start: import("convex/server").RegisteredMutation<"public", {
+    stepFunctionHandle: string;
+    totalSteps: number;
+    maxAttemptsPerStep: number;
+    kind: string;
+}, Promise<import("convex/values").GenericId<"durableJobs">>>;
+export declare const getStatus: import("convex/server").RegisteredQuery<"public", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+}, Promise<{
+    status: "running" | "completed" | "abandoned" | "cancelled";
+    cursor: number;
+    totalSteps: number;
+    lastError: string | undefined;
+    abandonedAtStep: number | undefined;
+}>>;
+export declare const cancel: import("convex/server").RegisteredMutation<"public", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+}, Promise<null>>;
+export declare const getJobInternal: import("convex/server").RegisteredQuery<"internal", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+}, Promise<{
+    cursor: number;
+    totalSteps: number;
+    maxAttemptsPerStep: number;
+    status: "running" | "completed" | "abandoned" | "cancelled";
+} | null>>;
+export declare const runStepInternal: import("convex/server").RegisteredMutation<"internal", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+}, Promise<null>>;
+export declare const markAbandonedInternal: import("convex/server").RegisteredMutation<"internal", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+    error: string;
+}, Promise<null>>;
+export declare const markCompletedInternal: import("convex/server").RegisteredMutation<"internal", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+}, 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">;
+}>, WorkflowId>;

package/dist/component/engine/durableJob.js

@@ -0,0 +1,262 @@
+import { v } from "convex/values";
+import { WorkflowManager } from "@convex-dev/workflow";
+import { components, internal } from "../_generated/api";
+import { internalMutation, internalQuery, mutation, query, } from "../_generated/server";
+import { assertSameOrg, requireOrgId } from "../lib/auth";
+// durableJobs — THE SURVIVAL CONTRACT (I1, SYNTHESE.md §5/§7): "mise en
+// pause à la frontière d'étape, rejeu déterministe, reprise, abandon après
+// N échecs." 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 -- VantagePeers/Sigma first --
+// 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, I0 §7.1) -- 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";
+export const workflow = new WorkflowManager(components.workflow);
+// ---------------------------------------------------------------------
+// PUBLIC CONTRACT
+// ---------------------------------------------------------------------
+export const start = mutation({
+    args: {
+        kind: v.string(),
+        stepFunctionHandle: v.string(),
+        totalSteps: v.number(),
+        maxAttemptsPerStep: v.number(),
+    },
+    returns: v.id("durableJobs"),
+    handler: async (ctx, args) => {
+        const orgId = await requireOrgId(ctx);
+        if (!Number.isInteger(args.totalSteps) || args.totalSteps <= 0) {
+            throw new Error("Validation: totalSteps must be a positive integer");
+        }
+        if (!Number.isInteger(args.maxAttemptsPerStep) ||
+            args.maxAttemptsPerStep <= 0) {
+            throw new Error("Validation: maxAttemptsPerStep must be a positive integer");
+        }
+        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", {
+            orgId,
+            kind: args.kind,
+            stepFunctionHandle: args.stepFunctionHandle,
+            totalSteps: args.totalSteps,
+            maxAttemptsPerStep: args.maxAttemptsPerStep,
+            cursor: 0,
+            status: "running",
+            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;
+    },
+});
+export const getStatus = query({
+    args: { jobId: v.id("durableJobs") },
+    returns: v.object({
+        status: v.union(v.literal("running"), v.literal("completed"), v.literal("abandoned"), v.literal("cancelled")),
+        cursor: v.number(),
+        totalSteps: v.number(),
+        lastError: v.optional(v.string()),
+        abandonedAtStep: v.optional(v.number()),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = await requireOrgId(ctx);
+        const job = await ctx.db.get(args.jobId);
+        assertSameOrg(orgId, job, "Job not found");
+        return {
+            status: job.status,
+            cursor: job.cursor,
+            totalSteps: job.totalSteps,
+            lastError: job.lastError,
+            abandonedAtStep: job.abandonedAtStep,
+        };
+    },
+});
+export const cancel = mutation({
+    args: { jobId: v.id("durableJobs") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = await requireOrgId(ctx);
+        const job = await ctx.db.get(args.jobId);
+        assertSameOrg(orgId, job, "Job not found");
+        if (job.status !== "running")
+            return null;
+        await ctx.db.patch(args.jobId, {
+            status: "cancelled",
+            updatedAt: Date.now(),
+        });
+        if (job.workflowId) {
+            await workflow.cancel(ctx, job.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") },
+    returns: v.union(v.object({
+        cursor: v.number(),
+        totalSteps: v.number(),
+        maxAttemptsPerStep: v.number(),
+        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)
+            return null;
+        return {
+            cursor: job.cursor,
+            totalSteps: job.totalSteps,
+            maxAttemptsPerStep: job.maxAttemptsPerStep,
+            status: job.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() },
+    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")
+            return null;
+        if (args.stepIndex < job.cursor) {
+            // Already-completed step replayed by a resumed workflow -- no-op.
+            return null;
+        }
+        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(),
+                });
+                return null;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(String(lastError));
+    },
+});
+export const markAbandonedInternal = internalMutation({
+    args: { jobId: v.id("durableJobs"), 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")
+            return null;
+        await ctx.db.patch(args.jobId, {
+            status: "abandoned",
+            abandonedAtStep: args.stepIndex,
+            lastError: args.error,
+            updatedAt: Date.now(),
+        });
+        return null;
+    },
+});
+export const markCompletedInternal = internalMutation({
+    args: { jobId: v.id("durableJobs") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const job = await ctx.db.get(args.jobId);
+        if (!job || job.status !== "running")
+            return null;
+        await ctx.db.patch(args.jobId, {
+            status: "completed",
+            updatedAt: Date.now(),
+        });
+        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") },
+    returns: v.null(),
+    handler: async (step, args) => {
+        const job = await step.runQuery(internal.engine.durableJob.getJobInternal, {
+            jobId: args.jobId,
+        });
+        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,
+                    stepIndex: i,
+                });
+            }
+            catch (err) {
+                await step.runMutation(internal.engine.durableJob.markAbandonedInternal, {
+                    jobId: args.jobId,
+                    stepIndex: i,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return null;
+            }
+        }
+        await step.runMutation(internal.engine.durableJob.markCompletedInternal, {
+            jobId: args.jobId,
+        });
+        return null;
+    },
+});

package/dist/component/lib/auth.d.ts

@@ -0,0 +1,7 @@
+import type { QueryCtx, MutationCtx } from "../_generated/server";
+export declare function requireOrgId(ctx: QueryCtx | MutationCtx): Promise<string>;
+export declare function assertSameOrg(callerOrgId: string, doc: {
+    orgId: string;
+} | null, notFoundMessage: string): asserts doc is {
+    orgId: string;
+};

package/dist/component/lib/auth.js

@@ -0,0 +1,24 @@
+// Deny by default. orgId is NEVER read from client args — it is derived
+// server-side from the authenticated identity (Clerk org claim). Every
+// mutation/query in this component must call this before touching data.
+export async function requireOrgId(ctx) {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+        throw new Error("Unauthenticated: no identity on ctx.auth");
+    }
+    // Clerk org-scoped JWT template exposes `org_id` as a top-level claim.
+    const orgId = identity.org_id;
+    if (!orgId || typeof orgId !== "string" || orgId.length === 0) {
+        throw new Error("Unauthenticated: identity carries no org_id claim");
+    }
+    return orgId;
+}
+// Throws unless the document's orgId matches the caller's server-derived
+// orgId. Use on every read/write of a document fetched by _id, since
+// db.get() does not filter by index.
+export function assertSameOrg(callerOrgId, doc, notFoundMessage) {
+    if (!doc || doc.orgId !== callerOrgId) {
+        // Same error for "not found" and "cross-org" -- do not leak existence.
+        throw new Error(notFoundMessage);
+    }
+}

package/dist/component/schema.d.ts

@@ -0,0 +1,49 @@
+declare const _default: import("convex/server").SchemaDefinition<{
+    durableJobs: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        workflowId?: string | undefined;
+        lastError?: string | undefined;
+        abandonedAtStep?: number | undefined;
+        orgId: string;
+        stepFunctionHandle: string;
+        totalSteps: number;
+        maxAttemptsPerStep: number;
+        cursor: number;
+        status: "running" | "completed" | "abandoned" | "cancelled";
+        workflowVersion: string;
+        createdAt: number;
+        updatedAt: number;
+        kind: string;
+    }, {
+        orgId: import("convex/values").VString<string, "required">;
+        kind: import("convex/values").VString<string, "required">;
+        stepFunctionHandle: import("convex/values").VString<string, "required">;
+        totalSteps: import("convex/values").VFloat64<number, "required">;
+        maxAttemptsPerStep: import("convex/values").VFloat64<number, "required">;
+        cursor: import("convex/values").VFloat64<number, "required">;
+        status: import("convex/values").VUnion<"running" | "completed" | "abandoned" | "cancelled", [import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"abandoned", "required">, import("convex/values").VLiteral<"cancelled", "required">], "required", never>;
+        workflowId: import("convex/values").VString<string | undefined, "optional">;
+        workflowVersion: import("convex/values").VString<string, "required">;
+        lastError: import("convex/values").VString<string | undefined, "optional">;
+        abandonedAtStep: import("convex/values").VFloat64<number | undefined, "optional">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "orgId" | "stepFunctionHandle" | "totalSteps" | "maxAttemptsPerStep" | "cursor" | "status" | "workflowId" | "workflowVersion" | "lastError" | "abandonedAtStep" | "createdAt" | "updatedAt" | "kind">, {
+        by_org: ["orgId", "_creationTime"];
+        by_org_status: ["orgId", "status", "_creationTime"];
+    }, {}, {}>;
+    callerStepInvocations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        orgId: string;
+        createdAt: number;
+        jobId: import("convex/values").GenericId<"durableJobs">;
+        stepIndex: number;
+    }, {
+        orgId: import("convex/values").VString<string, "required">;
+        jobId: import("convex/values").VId<import("convex/values").GenericId<"durableJobs">, "required">;
+        stepIndex: import("convex/values").VFloat64<number, "required">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "orgId" | "createdAt" | "jobId" | "stepIndex">, {
+        by_org: ["orgId", "_creationTime"];
+        by_org_job: ["orgId", "jobId", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;

package/dist/component/schema.js

@@ -0,0 +1,56 @@
+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, deliberately narrow — see README "What's callable"):
+// only the tables `engine/durableJob.ts` requires. The full agent
+// aggregate (agents, skills, subagents, connections, habits,
+// sandboxConfig, toolApprovals, modelKeys, sessions, sessionEvents,
+// awaitEventTimeouts, wakeableWork, wakeupDemoResults) is NOT yet
+// re-hosted under this component boundary — that is the next, separately
+// scoped migration. Porting the durableJob engine first unblocks
+// VantagePeers/Sigma's I1 need (durable long-task survival) without
+// widening the surface being shipped-and-verified beyond what has an
+// actual working component-level test harness behind it (Day 128: never
+// ship unverified).
+export default defineSchema({
+    // durableJobs — GENERIC durable step-batch primitive (I1, SYNTHESE.md
+    // §5/§7). See convex/engine/durableJob.ts (repo root) for the full
+    // contract description; this table definition is byte-identical to the
+    // one there.
+    durableJobs: defineTable({
+        orgId: v.string(),
+        kind: v.string(),
+        stepFunctionHandle: v.string(),
+        totalSteps: v.number(),
+        maxAttemptsPerStep: v.number(),
+        cursor: v.number(),
+        status: v.union(v.literal("running"), v.literal("completed"), v.literal("abandoned"), v.literal("cancelled")),
+        workflowId: v.optional(v.string()),
+        workflowVersion: v.string(),
+        lastError: v.optional(v.string()),
+        abandonedAtStep: v.optional(v.number()),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .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"),
+        stepIndex: v.number(),
+        createdAt: v.number(),
+    })
+        .index("by_org", ["orgId"])
+        .index("by_org_job", ["orgId", "jobId"]),
+});

package/dist/component/testFixtures/callerSteps.d.ts

@@ -0,0 +1,20 @@
+export declare const getAttemptCount: import("convex/server").RegisteredQuery<"internal", {
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+}, Promise<number>>;
+export declare const resetAttemptCounts: import("convex/server").RegisteredMutation<"internal", {}, Promise<null>>;
+export declare const alwaysSucceeds: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+}, Promise<null>>;
+export declare const alwaysFails: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+}, Promise<never>>;
+export declare const failsFirstAttemptThenSucceeds: import("convex/server").RegisteredMutation<"internal", {
+    orgId: string;
+    jobId: import("convex/values").GenericId<"durableJobs">;
+    stepIndex: number;
+}, Promise<null>>;

package/dist/component/testFixtures/callerSteps.js

@@ -0,0 +1,90 @@
+import { v } from "convex/values";
+import { internalMutation, internalQuery } from "../_generated/server";
+// testFixtures/callerSteps — stand-ins for a CALLER'S OWN step function
+// (the thing a real consumer, e.g. VantagePeers, would define in ITS OWN
+// app and pass to `engine/durableJob.start` as `stepFunctionHandle` via
+// `createFunctionHandle`). These exist ONLY to drive the contract tests in
+// convex/engineDurableJob.test.ts -- they are not part of the public
+// surface (see examples/vantage-peers-long-task for the real, documented
+// integration a consumer would write).
+//
+// Attempt counts are tracked IN-MEMORY (module-level Map), not via a DB
+// write, because a mutation that throws rolls back every write made in its
+// OWN transaction -- including a "record that I was called" insert made
+// just before the throw. In-memory state survives the rollback since it is
+// plain JS state, not part of the Convex transaction.
+const attemptCounts = new Map();
+function bump(jobId, stepIndex) {
+    const key = `${jobId}:${stepIndex}`;
+    const next = (attemptCounts.get(key) ?? 0) + 1;
+    attemptCounts.set(key, next);
+    return next;
+}
+export const getAttemptCount = internalQuery({
+    args: { jobId: v.id("durableJobs"), stepIndex: v.number() },
+    returns: v.number(),
+    handler: async (_ctx, args) => {
+        return attemptCounts.get(`${args.jobId}:${args.stepIndex}`) ?? 0;
+    },
+});
+// TEST-ONLY: `convexTest()` reuses deterministic, low-cardinality document
+// IDs across SEPARATE test instances within the same process, so this
+// module-level Map must be cleared between tests to avoid one test's
+// counters leaking into the next via a colliding `${jobId}:${stepIndex}`
+// key. Called from `beforeEach` in engineDurableJob.test.ts.
+export const resetAttemptCounts = internalMutation({
+    args: {},
+    returns: v.null(),
+    handler: async () => {
+        attemptCounts.clear();
+        return null;
+    },
+});
+// Records one row per SUCCESSFUL invocation so tests can assert exactly
+// which step indices actually completed (idempotent-replay assertions).
+export const alwaysSucceeds = internalMutation({
+    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        bump(args.jobId, args.stepIndex);
+        await ctx.db.insert("callerStepInvocations", {
+            orgId: args.orgId,
+            jobId: args.jobId,
+            stepIndex: args.stepIndex,
+            createdAt: Date.now(),
+        });
+        return null;
+    },
+});
+// Fails on every attempt -- used to prove "abandon after N échecs". Attempt
+// count is observable via `getAttemptCount` even though every DB write this
+// function might otherwise make would be rolled back by the throw.
+export const alwaysFails = internalMutation({
+    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
+    returns: v.null(),
+    handler: async (_ctx, args) => {
+        bump(args.jobId, args.stepIndex);
+        throw new Error(`simulated failure at step ${args.stepIndex}`);
+    },
+});
+// Fails on the FIRST attempt of ANY step, then succeeds on every
+// subsequent attempt of that same step -- used to prove retry-then-succeed
+// still advances the cursor (not just outright failure), exercising the
+// `maxAttemptsPerStep > 1` path distinctly from `alwaysFails`.
+export const failsFirstAttemptThenSucceeds = internalMutation({
+    args: { orgId: v.string(), jobId: v.id("durableJobs"), stepIndex: v.number() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const attemptNumber = bump(args.jobId, args.stepIndex);
+        if (attemptNumber === 1) {
+            throw new Error(`simulated single failure at step ${args.stepIndex}`);
+        }
+        await ctx.db.insert("callerStepInvocations", {
+            orgId: args.orgId,
+            jobId: args.jobId,
+            stepIndex: args.stepIndex,
+            createdAt: Date.now(),
+        });
+        return null;
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vantageos/agent-engine",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "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": "UNLICENSED",
@@ -21,6 +21,9 @@
     "./convex.config.js": {
       "types": "./dist/component/convex.config.d.ts",
       "default": "./dist/component/convex.config.js"
+    },
+    "./_generated/component.js": {
+      "types": "./dist/component/_generated/component.d.ts"
     }
   },
   "scripts": {