@vantageos/agent-engine 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/component/engine/vpConnection.js

@@ -0,0 +1,221 @@
+import { v } from "convex/values";
+import { action, internalMutation, internalQuery, mutation, query, } from "../_generated/server.js";
+import { assertSameOrg, requireOrgId } from "../lib/auth.js";
+import { internal } from "../_generated/api.js";
+// engine/vpConnection — C6 (I6.b), mvp-evevantage.md §2.2 "Travail
+// d'équipe". Ported from convex/engine/vpConnection.ts (repo-root
+// prototype) into the component boundary (C6). The four VantagePeers tools
+// (memory, tasks, messages, notes) are wired as a CONNECTION of the agent
+// aggregate -- notre ligne, same slot family as `connections` (MCP/OpenAPI).
+// Four toggles, ON by default.
+//
+// DIRECT ACCESS, NO NETWORK IN THE HOT PATH: `invokeVpTool` dispatches via a
+// caller-supplied Convex function handle (`createFunctionHandle`), the same
+// discipline `engine/wakeup.ts` and `engine/durableJob.ts` already use for
+// `workFunctionHandle` / `stepFunctionHandle` -- an in-process function
+// reference resolved by `ctx.runMutation`, never an HTTP request. grep proof
+// (cited in the PR/README): this file contains zero occurrences of the
+// literal fetch call.
+//
+// C6 orgId discipline (component/lib/auth.ts): every PUBLIC function takes
+// `orgId` as an explicit ARGUMENT (auth does not propagate across a
+// component boundary). `orgId` is passed EXPLICITLY to the target function
+// handle (never trusting the target's own `ctx.auth`) -- this is the
+// isolation guarantee the org-scoped write depends on: the target function
+// is expected to write scoped to the `orgId` it was HANDED, not to derive
+// one itself.
+const vpTool = v.union(v.literal("memory"), v.literal("tasks"), v.literal("messages"), v.literal("notes"));
+// defaultToggles — mvp §2.2: "quatre interrupteurs cochés par défaut". A
+// missing `vpConnections` row means "use these defaults", so every agent
+// starts with all four VP tools available with zero extra setup.
+export const defaultToggles = {
+    memoryEnabled: true,
+    tasksEnabled: true,
+    messagesEnabled: true,
+    notesEnabled: true,
+};
+const vpConnectionDoc = v.object({
+    _id: v.id("vpConnections"),
+    _creationTime: v.number(),
+    orgId: v.string(),
+    agentId: v.id("agents"),
+    memoryEnabled: v.boolean(),
+    tasksEnabled: v.boolean(),
+    messagesEnabled: v.boolean(),
+    notesEnabled: v.boolean(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+});
+// get — the raw connection row, if a human ever touched the toggles.
+export const get = query({
+    args: { orgId: v.string(), agentId: v.id("agents") },
+    returns: v.union(vpConnectionDoc, v.null()),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const agent = await ctx.db.get(args.agentId);
+        assertSameOrg(orgId, agent, "Agent not found");
+        return await ctx.db
+            .query("vpConnections")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .unique();
+    },
+});
+// getToggles — resolves the effective toggle state (row if present, else
+// the checked-by-default set) for a given agent.
+export const getToggles = query({
+    args: { orgId: v.string(), agentId: v.id("agents") },
+    returns: v.object({
+        memoryEnabled: v.boolean(),
+        tasksEnabled: v.boolean(),
+        messagesEnabled: v.boolean(),
+        notesEnabled: v.boolean(),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const agent = await ctx.db.get(args.agentId);
+        assertSameOrg(orgId, agent, "Agent not found");
+        const row = await ctx.db
+            .query("vpConnections")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .unique();
+        return row
+            ? {
+                memoryEnabled: row.memoryEnabled,
+                tasksEnabled: row.tasksEnabled,
+                messagesEnabled: row.messagesEnabled,
+                notesEnabled: row.notesEnabled,
+            }
+            : defaultToggles;
+    },
+});
+// setToggles — upserts the four switches (an explicit human choice to turn
+// one off; still ON by default until touched).
+export const setToggles = mutation({
+    args: {
+        orgId: v.string(),
+        agentId: v.id("agents"),
+        memoryEnabled: v.optional(v.boolean()),
+        tasksEnabled: v.optional(v.boolean()),
+        messagesEnabled: v.optional(v.boolean()),
+        notesEnabled: v.optional(v.boolean()),
+    },
+    returns: v.id("vpConnections"),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const agent = await ctx.db.get(args.agentId);
+        assertSameOrg(orgId, agent, "Agent not found");
+        const existing = await ctx.db
+            .query("vpConnections")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", orgId).eq("agentId", args.agentId))
+            .unique();
+        const now = Date.now();
+        const merged = {
+            memoryEnabled: args.memoryEnabled ?? existing?.memoryEnabled ?? defaultToggles.memoryEnabled,
+            tasksEnabled: args.tasksEnabled ?? existing?.tasksEnabled ?? defaultToggles.tasksEnabled,
+            messagesEnabled: args.messagesEnabled ?? existing?.messagesEnabled ?? defaultToggles.messagesEnabled,
+            notesEnabled: args.notesEnabled ?? existing?.notesEnabled ?? defaultToggles.notesEnabled,
+        };
+        if (existing) {
+            await ctx.db.patch(existing._id, { ...merged, updatedAt: now });
+            return existing._id;
+        }
+        return await ctx.db.insert("vpConnections", {
+            orgId,
+            agentId: args.agentId,
+            ...merged,
+            createdAt: now,
+            updatedAt: now,
+        });
+    },
+});
+function toggleFor(toggles, tool) {
+    return tool === "memory"
+        ? toggles.memoryEnabled
+        : tool === "tasks"
+            ? toggles.tasksEnabled
+            : tool === "messages"
+                ? toggles.messagesEnabled
+                : toggles.notesEnabled;
+}
+// invokeVpTool — the direct-access dispatch. `vpFunctionHandle` is an
+// opaque handle string obtained via `createFunctionHandle` against a
+// mutation the VantagePeers tenant exposes (same-app or cross-app handle,
+// per Convex's own `createFunctionHandle` contract -- never a URL, never an
+// HTTP fetch call). The engine passes `orgId` EXPLICITLY as an argument
+// (never trusting the target's own `ctx.auth`, since this may cross an
+// app/component boundary) -- this is the isolation guarantee the org-scoped
+// write depends on: the target function is expected to write scoped to the
+// `orgId` it was HANDED, not to derive one itself.
+export const invokeVpTool = action({
+    args: {
+        orgId: v.string(),
+        agentId: v.id("agents"),
+        tool: vpTool,
+        vpFunctionHandle: v.string(),
+        argsJson: v.string(),
+    },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const toggles = await ctx.runQuery(internal.engine.vpConnection.getTogglesInternal, {
+            orgId,
+            agentId: args.agentId,
+        });
+        if (!toggles) {
+            throw new Error("Agent not found");
+        }
+        if (!toggleFor(toggles, args.tool)) {
+            throw new Error(`VantagePeers tool "${args.tool}" is disabled for this agent`);
+        }
+        // In-process dispatch by function handle -- NOT an HTTP fetch call, NOT
+        // an HTTP hop. `orgId` is threaded explicitly so the write lands in the
+        // CALLING agent's org tenant regardless of which org's identity (if
+        // any) the target function's own `ctx.auth` would otherwise resolve.
+        await ctx.runMutation(args.vpFunctionHandle, { orgId, argsJson: args.argsJson });
+        await ctx.runMutation(internal.engine.vpConnection.recordInvocationInternal, {
+            orgId,
+            agentId: args.agentId,
+            tool: args.tool,
+        });
+        return null;
+    },
+});
+export const getTogglesInternal = internalQuery({
+    args: { orgId: v.string(), agentId: v.id("agents") },
+    returns: v.union(v.object({
+        memoryEnabled: v.boolean(),
+        tasksEnabled: v.boolean(),
+        messagesEnabled: v.boolean(),
+        notesEnabled: v.boolean(),
+    }), v.null()),
+    handler: async (ctx, args) => {
+        const agent = await ctx.db.get(args.agentId);
+        if (!agent || agent.orgId !== args.orgId)
+            return null;
+        const row = await ctx.db
+            .query("vpConnections")
+            .withIndex("by_org_agent", (q) => q.eq("orgId", args.orgId).eq("agentId", args.agentId))
+            .unique();
+        return row
+            ? {
+                memoryEnabled: row.memoryEnabled,
+                tasksEnabled: row.tasksEnabled,
+                messagesEnabled: row.messagesEnabled,
+                notesEnabled: row.notesEnabled,
+            }
+            : defaultToggles;
+    },
+});
+export const recordInvocationInternal = internalMutation({
+    args: { orgId: v.string(), agentId: v.id("agents"), tool: vpTool },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        await ctx.db.insert("vpToolInvocations", {
+            orgId: args.orgId,
+            agentId: args.agentId,
+            tool: args.tool,
+            createdAt: Date.now(),
+        });
+        return null;
+    },
+});

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

@@ -0,0 +1,33 @@
+import { Workpool } from "@convex-dev/workpool";
+import type { Id } from "../_generated/dataModel.js";
+export declare const wakeupPool: Workpool;
+export declare const enqueue: import("convex/server").RegisteredAction<"public", {
+    payload?: string | undefined;
+    orgId: string;
+    workflowId: string;
+    agentId: import("convex/values").GenericId<"agents">;
+    awaitedEventName: string;
+    scope: string;
+    reason: string;
+    cost: number;
+    workFunctionHandle: string;
+}, Promise<Id<"wakeableWork">>>;
+export declare const enqueueInternal: import("convex/server").RegisteredMutation<"internal", {
+    payload?: string | undefined;
+    orgId: string;
+    workflowId: string;
+    awaitedEventName: string;
+    workFunctionHandle: string;
+}, Promise<Id<"wakeableWork">>>;
+export declare const cancel: import("convex/server").RegisteredMutation<"public", {
+    orgId: string;
+    wakeableWorkId: import("convex/values").GenericId<"wakeableWork">;
+}, Promise<null>>;
+export declare const getStatus: import("convex/server").RegisteredQuery<"public", {
+    orgId: string;
+    wakeableWorkId: import("convex/values").GenericId<"wakeableWork">;
+}, Promise<{
+    status: "completed" | "cancelled" | "pending" | "failed";
+    resultSummary: string | undefined;
+}>>;
+export declare const onWorkComplete: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workpool").OnCompleteArgs, null>;

package/dist/component/engine/wakeup.js

@@ -0,0 +1,230 @@
+import { Workpool } from "@convex-dev/workpool";
+import { v } from "convex/values";
+import { WorkflowManager } from "@convex-dev/workflow";
+import { components, internal } from "../_generated/api.js";
+import { action, internalMutation, mutation, query } from "../_generated/server.js";
+import { assertSameOrg, requireOrgId } from "../lib/auth.js";
+// engine/wakeup — THE GENERIC WAKE-UP PRIMITIVE (I2, SYNTHESE.md §5: "Adam
+// ne demande pas toutes les minutes s'il y a du travail -- il est réveillé
+// quand du travail arrive"). PORTED from convex/engine/wakeup.ts (repo-root
+// prototype) into the component boundary (C2). Mechanism: `enqueue` puts
+// caller-supplied work (an action, referenced by an opaque handle string
+// from `createFunctionHandle` in the CALLER's own app, same
+// component-isolation discipline as `durableJob.stepFunctionHandle`) into a
+// dedicated `@convex-dev/workpool` (`components.wakeupPool`, declared in
+// component/convex.config.ts). That pool's `onComplete` callback -- which
+// fires in its OWN transaction once the work resolves (I0 §2: "onComplete
+// en transaction séparée, pas de pause native", workpool issue #133) --
+// calls `workflow.sendEvent(...)` against the CALLER-supplied
+// `workflowId`. Any workflow step parked on
+// `step.awaitEvent({ name: awaitedEventName })` resumes the INSTANT that
+// event lands -- no interval, no cron, no re-query loop. This fires for
+// success, failure, AND cancellation alike: see `onWorkComplete` below -- a
+// sleeping agent whose work silently died is worse than a polling one.
+//
+// Decoupled from `sessions`/`durableJobs` by design: any workflow (a
+// session, a durable job, or a bespoke one) can be the wake target by
+// handing us its own `workflowId` -- this table/module never reads either
+// of those tables.
+//
+// ---------------------------------------------------------------------
+// C2 MIGRATION NOTES ("notre ligne")
+// ---------------------------------------------------------------------
+//
+// (A) orgId is an EXPLICIT ARGUMENT on every public function, never derived
+// from `ctx.auth` -- auth does NOT propagate across a component boundary
+// (see component/lib/auth.ts). The consumer app has already authenticated
+// its caller and resolved orgId on its OWN side before calling in.
+//
+// (B) C3: MANDATE FUNDING CHOKE-POINT IS NOW WIRED. `enqueue` is an
+// `action` because funding-then-starting is a TWO-TRANSACTION protocol a
+// single mutation cannot express: `mandates.spendInternal` must be able to
+// COMMIT an `approvalRequests` row on an overrun WITHOUT that commit being
+// rolled back by a subsequent throw in the same transaction (see the
+// transactional argument in `component/engine/mandates.ts:spendCore`,
+// proven by the MUST_BLOCK probe in `component/engine/mandates.test.ts`).
+// The action:
+//   1. validates `orgId` (the ARGUMENT the caller supplies -- see note A;
+//      this component never reads `ctx.auth`),
+//   2. runs `mandates.spendInternal` in its OWN transaction
+//      (`ctx.runMutation`),
+//   3. throws immediately if `!result.ok` -- refuses end-to-end. The
+//      approval-request row from step 2 has ALREADY committed, because it
+//      lives in a transaction that already returned before this throw runs.
+//   4. only on `result.ok === true` does it call `enqueueInternal` in a
+//      SECOND transaction to actually put the work in the pool.
+// There is no code path from "client wants work started" to "work enters
+// the pool" that does not pass through step 2 -- this is the "argument you
+// cannot fabricate" form (Pi/Sigma, T4 lesson): the only way to make
+// `enqueueInternal` run at all is to be `enqueue` itself, and `enqueue`
+// always calls `mandates.spendInternal` first. Mirrors the app-level
+// pre-C2 prototype (`convex/engine/wakeup.ts`) exactly, adapted to the
+// orgId-argument discipline of this component boundary (`spendInternal`
+// takes `orgId` as an argument rather than deriving it from `ctx.auth`).
+export const wakeupPool = new Workpool(components.wakeupPool, {
+    maxParallelism: 10,
+});
+// Same WorkflowManager COMPONENT as engine/workflows.ts (components.workflow)
+// -- a fresh WorkflowManager instance bound to the same component is safe
+// to construct per-module; the manager itself holds no local state, it
+// only forwards to the component.
+const workflow = new WorkflowManager(components.workflow);
+// ---------------------------------------------------------------------
+// PUBLIC CONTRACT
+// ---------------------------------------------------------------------
+// enqueue — the ONLY client-facing entry point (C3: now an `action`, see
+// note B above). Funds the work through `mandates.spendInternal` in its
+// own transaction FIRST; only calls `enqueueInternal` (a second,
+// independent transaction) once that funding succeeded.
+export const enqueue = action({
+    args: {
+        orgId: v.string(),
+        agentId: v.id("agents"),
+        scope: v.string(),
+        cost: v.number(),
+        reason: v.string(),
+        workflowId: v.string(),
+        awaitedEventName: v.string(),
+        workFunctionHandle: v.string(),
+        payload: v.optional(v.string()),
+    },
+    returns: v.id("wakeableWork"),
+    handler: async (ctx, args) => {
+        // orgId is a caller-supplied ARGUMENT, validated here (not derived from
+        // ctx.auth -- component boundaries do not propagate auth, see note A
+        // and component/lib/auth.ts). Validated BEFORE the funding call so a
+        // missing orgId is refused with OUR message, not a downstream one.
+        const orgId = requireOrgId(args.orgId);
+        const result = await ctx.runMutation(internal.engine.mandates.spendInternal, {
+            orgId,
+            agentId: args.agentId,
+            scope: args.scope,
+            cost: args.cost,
+            reason: args.reason,
+        });
+        if (!result.ok) {
+            // REFUSED end-to-end: the approval request already committed inside
+            // `mandates.spendInternal`'s own transaction (step above); no
+            // further transaction runs, so the work never enters the pool.
+            throw new Error(`Mandate refused: agent ${args.agentId} has no remaining authority ` +
+                `for scope "${args.scope}" (cost ${args.cost}). Approval request ` +
+                `${result.approvalId} was created and is pending human review.`);
+        }
+        return await ctx.runMutation(internal.engine.wakeup.enqueueInternal, {
+            orgId,
+            workflowId: args.workflowId,
+            awaitedEventName: args.awaitedEventName,
+            workFunctionHandle: args.workFunctionHandle,
+            payload: args.payload,
+        });
+    },
+});
+// enqueueInternal -- INTERNAL ONLY variant, kept for the C3 two-transaction
+// protocol (a future funding `action` calls this in its SECOND transaction
+// once `mandates.spend` returned `{ ok: true }`, same split as the
+// app-level prototype). Unreachable from any client: Convex excludes
+// `internal.*` functions from the API surface shipped to clients.
+export const enqueueInternal = internalMutation({
+    args: {
+        orgId: v.string(),
+        workflowId: v.string(),
+        awaitedEventName: v.string(),
+        workFunctionHandle: v.string(),
+        payload: v.optional(v.string()),
+    },
+    returns: v.id("wakeableWork"),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        if (args.workflowId.length === 0) {
+            throw new Error("Validation: workflowId must not be empty");
+        }
+        if (args.awaitedEventName.length === 0) {
+            throw new Error("Validation: awaitedEventName must not be empty");
+        }
+        if (args.workFunctionHandle.length === 0) {
+            throw new Error("Validation: workFunctionHandle must not be empty");
+        }
+        const now = Date.now();
+        const wakeableWorkId = await ctx.db.insert("wakeableWork", {
+            orgId,
+            workflowId: args.workflowId,
+            awaitedEventName: args.awaitedEventName,
+            workId: "",
+            status: "pending",
+            createdAt: now,
+            updatedAt: now,
+        });
+        const workId = await wakeupPool.enqueueAction(ctx, args.workFunctionHandle, { orgId, payload: args.payload }, { onComplete: internal.engine.wakeup.onWorkComplete, context: { wakeableWorkId } });
+        await ctx.db.patch(wakeableWorkId, { workId });
+        return wakeableWorkId;
+    },
+});
+// Best-effort cancel -- lets a caller pull work back out of the pool before
+// it starts; the wake still fires (workpool reports `kind: "canceled"` to
+// `onComplete`, see below) so the awaiting workflow is never left hanging.
+export const cancel = mutation({
+    args: { orgId: v.string(), wakeableWorkId: v.id("wakeableWork") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const row = await ctx.db.get(args.wakeableWorkId);
+        assertSameOrg(orgId, row, "Wakeable work not found");
+        if (row.status !== "pending")
+            return null;
+        await wakeupPool.cancel(ctx, row.workId);
+        return null;
+    },
+});
+export const getStatus = query({
+    args: { orgId: v.string(), wakeableWorkId: v.id("wakeableWork") },
+    returns: v.object({
+        status: v.union(v.literal("pending"), v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
+        resultSummary: v.optional(v.string()),
+    }),
+    handler: async (ctx, args) => {
+        const orgId = requireOrgId(args.orgId);
+        const row = await ctx.db.get(args.wakeableWorkId);
+        assertSameOrg(orgId, row, "Wakeable work not found");
+        return { status: row.status, resultSummary: row.resultSummary };
+    },
+});
+// ---------------------------------------------------------------------
+// INTERNAL — the wake itself. Invoked ONLY by the workpool's own
+// completion machinery (defineOnComplete), never by a client and never on
+// a timer.
+// ---------------------------------------------------------------------
+// THE WAKE. This is the entire mechanism: onComplete -> sendEvent. It is a
+// mutation the workpool component calls exactly once per work item, in its
+// own transaction, at the moment the work resolves -- whichever way it
+// resolves. All three `result.kind`s below reach `sendEvent`: a workflow
+// asleep because its work vanished (failed/cancelled, no wake) would be
+// strictly worse than one that polls.
+const onWorkCompleteContext = v.object({ wakeableWorkId: v.id("wakeableWork") });
+export const onWorkComplete = wakeupPool.defineOnComplete({
+    context: onWorkCompleteContext,
+    handler: async (ctx, { context, result }) => {
+        const row = await ctx.db.get(context.wakeableWorkId);
+        if (!row)
+            return; // work outlived its tracking row -- nothing to wake
+        const status = result.kind === "success"
+            ? "completed"
+            : result.kind === "failed"
+                ? "failed"
+                : "cancelled";
+        const resultSummary = result.kind === "failed" ? result.error : undefined;
+        await ctx.db.patch(row._id, {
+            status,
+            resultSummary,
+            updatedAt: Date.now(),
+        });
+        await workflow.sendEvent(ctx, {
+            workflowId: row.workflowId,
+            name: row.awaitedEventName,
+            validator: v.object({
+                status: v.union(v.literal("completed"), v.literal("failed"), v.literal("cancelled")),
+                resultSummary: v.optional(v.string()),
+            }),
+            value: { status, resultSummary },
+        });
+    },
+});

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

@@ -0,0 +1,11 @@
+import { WorkflowManager } from "@convex-dev/workflow";
+export declare const resolveManifestInternal: import("convex/server").RegisteredQuery<"internal", {
+    sessionId: import("convex/values").GenericId<"sessions">;
+}, Promise<null>>;
+export declare const recordTurnStartedInternal: import("convex/server").RegisteredMutation<"internal", {
+    sessionId: import("convex/values").GenericId<"sessions">;
+}, Promise<null>>;
+export declare const workflow: WorkflowManager;
+export declare const sessionWorkflowV1: import("convex/server").RegisteredMutation<"internal", import("@convex-dev/workflow").WorkflowArgs<{
+    sessionId: import("convex/values").VId<import("convex/values").GenericId<"sessions">, "required">;
+}>, import("@convex-dev/workflow").WorkflowId>;

package/dist/component/engine/workflows.js

@@ -0,0 +1,87 @@
+import { WorkflowManager } from "@convex-dev/workflow";
+import { v } from "convex/values";
+import { components, internal } from "../_generated/api.js";
+import { internalMutation, internalQuery } from "../_generated/server.js";
+// C1.5 — porting the durable, VERSIONED session workflow into the
+// component boundary (ported from the repo-root prototype,
+// convex/engine/workflows.ts). This is what makes `sessions.start` open a
+// session PILOTED by `@convex-dev/workflow` instead of the T2-QUINQUIES
+// "sessions are just an event table" divergence (component/schema.ts,
+// sessions table comment retired alongside this file).
+//
+// Trust model at this boundary: the workflow engine runs with NO end-user
+// identity and NO client-supplied orgId (component isolation, same
+// discipline as component/engine/durableJob.ts and component/lib/auth.ts).
+// Every internal step below reads orgId from the `sessions` row itself --
+// never from an argument a workflow step could be handed by a caller.
+// Internal (server-to-server only) variants of the resolver/session
+// mutations, used by the workflow step handlers below. The workflow engine
+// runs with no end-user identity, so these read/write scoped strictly by
+// the orgId already recorded on the session row -- never trusting a
+// client-supplied orgId.
+export const resolveManifestInternal = internalQuery({
+    args: { sessionId: v.id("sessions") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const session = await ctx.db.get(args.sessionId);
+        if (!session)
+            throw new Error("Session not found");
+        const agent = await ctx.db.get(session.agentId);
+        if (!agent || agent.orgId !== session.orgId) {
+            throw new Error("Agent not found");
+        }
+        // Resolution result is consumed by the caller via the public
+        // engine/resolvers:resolveManifest query; this internal step exists to
+        // prove (and test) that the reread happens at each boundary.
+        return null;
+    },
+});
+export const recordTurnStartedInternal = internalMutation({
+    args: { sessionId: v.id("sessions") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const session = await ctx.db.get(args.sessionId);
+        if (!session)
+            throw new Error("Session not found");
+        await ctx.db.insert("sessionEvents", {
+            orgId: session.orgId,
+            sessionId: args.sessionId,
+            name: "turn.started",
+            payload: undefined,
+            createdAt: Date.now(),
+        });
+        return null;
+    },
+});
+// Versioned workflow discipline (workflow#35, I0 §7.1): "if you change much
+// of anything in a workflow while there are ongoing workflows, they'll
+// fail." We never edit a workflow function in place once sessions
+// reference it -- a breaking change ships as `sessionWorkflowV2`, and the
+// deploy is preceded by draining v1 sessions (0 rows with
+// sessions.workflowVersion == "v1" and status == "running"). Same
+// discipline as `engine/durableJob.ts:durableJobWorkflowV1`.
+export const workflow = new WorkflowManager(components.workflow);
+// sessionWorkflowV1 -- the durable session loop. At `session.started` and
+// at every `turn.started` boundary it rereads the agent aggregate (never
+// cached, never compiled) via `resolveManifestInternal`. Tool approvals
+// pause the workflow via `step.awaitEvent`, guarded by the self-built
+// timeout (workflow#177) once that surface is ported into this component.
+export const sessionWorkflowV1 = workflow.define({
+    args: { sessionId: v.id("sessions") },
+    returns: v.null(),
+    handler: async (step, args) => {
+        // session.started boundary: read the aggregate once at start.
+        await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
+            sessionId: args.sessionId,
+        });
+        // turn.started boundary: re-read on every turn so an agent/skill edit
+        // made mid-session is visible at the very next turn, with zero deploy.
+        await step.runMutation(internal.engine.workflows.recordTurnStartedInternal, {
+            sessionId: args.sessionId,
+        });
+        await step.runQuery(internal.engine.workflows.resolveManifestInternal, {
+            sessionId: args.sessionId,
+        });
+        return null;
+    },
+});