@vercel/factory 0.0.15 → 0.0.16

package/dist/sweep.mjs

@@ -2,6 +2,7 @@ import { InvalidTransitionError } from "./schema/transitions.mjs";
 import { routeKey } from "./agent-routes.mjs";
 import { VersionConflictError } from "./store/driver.mjs";
 import { DispatchRefusedError, dispatchTask } from "./dispatch.mjs";
+import { TaskAttemptConflictError } from "./store/engine.mjs";
 //#region src/sweep.ts
 async function failUnrouteable(stores, task, reasonCode, reason, result) {
 	try {
@@ -27,12 +28,29 @@ async function failUnrouteable(stores, task, reasonCode, reason, result) {
 	}
 }
 /**
-* One pass of the factory's dispatcher, meant to run on a schedule inside the
-* deployment: every queued task that is allowed to run is started, in
-* creation order. Nothing outside the factory ever starts an agent; the CLI
-* only writes tasks and approvals, and this picks them up.
-* Idempotent by construction: dispatchTask's single-winner transition means
-* two overlapping sweeps cannot start the same task twice.
+* Runs one bounded pass over queued Tasks and dispatches each eligible exact route.
+*
+* @remarks
+* Candidates are ordered by newest attempt first and then creation time. Route-less work remains
+* queued for its workflow owner; unmet dependencies, approvals, and pass limits appear in
+* `skipped`. Invalid repository scope, missing repositories or launchers, and launch failures
+* appear in `failed`, with unrouteable Tasks transitioned to `failed` when this sweep wins the
+* race. A result entry describes this pass rather than guaranteeing the Task's lifecycle state:
+* an ambiguously accepted launch is reported as `launch_failed` while its Task intentionally stays
+* running for recovery. Callers should surface every failure, reread those Tasks before deciding
+* remediation, and schedule another pass for skipped work.
+*
+* Overlapping passes are safe: {@link dispatchTask} atomically admits one winner before invoking a
+* launcher. A supplied `tasks` snapshot bounds reads and candidate selection for this pass; it can
+* become stale, and corresponding races are returned as `task_changed` rather than hidden.
+* `maxDispatches` counts provider launches started during the pass, including launches that later
+* fail, so `dispatched.length` may be smaller than the limit.
+*
+* @param stores - Graph, receipt, repository, and Task stores used during the pass.
+* @param options - Exact-route launchers plus optional budget, Task snapshot, and dispatch limit.
+* @returns IDs dispatched and structured skipped/failed outcomes for every considered candidate.
+* @throws When `maxDispatches` is not a positive integer or an unexpected persistence error occurs.
+* @see The shipped `docs/recipes/retry-recovery.md` recipe for scheduled recovery.
 */
 async function sweepQueued(stores, options) {
 	const result = {
@@ -100,12 +118,14 @@ async function sweepQueued(stores, options) {
 			await failUnrouteable(stores, task, "repository_not_found", "task has no repository", result);
 			continue;
 		}
+		let launchStarted = false;
 		try {
 			const dispatched = await dispatchTask(stores, {
 				taskId: task.id,
 				route,
 				launch: (dispatched) => {
 					attempted += 1;
+					launchStarted = true;
 					return launcher(dispatched, repository);
 				},
 				budget: options.budget === void 0 ? void 0 : {
@@ -128,6 +148,14 @@ async function sweepQueued(stores, options) {
 				});
 				continue;
 			}
+			if (!launchStarted && (error instanceof InvalidTransitionError || error instanceof TaskAttemptConflictError || error instanceof VersionConflictError)) {
+				result.skipped.push({
+					taskId: task.id,
+					reasonCode: "task_changed",
+					reason: "task changed before dispatch"
+				});
+				continue;
+			}
 			result.failed.push({
 				taskId: task.id,
 				reasonCode: "launch_failed",

package/dist/sweep.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sweep.mjs","names":[],"sources":["../src/sweep.ts"],"sourcesContent":["import { routeKey, type AgentRouteKey } from \"./agent-routes\";\nimport { dispatchTask, DispatchRefusedError, type DispatchBudget } from \"./dispatch\";\nimport type { DispatchRefusalCode } from \"./dispatch\";\nimport type { TaskId } from \"./schema/id\";\nimport type { Repository } from \"./schema/repository\";\nimport type { ExecutionReference, Task } from \"./schema/task\";\nimport { InvalidTransitionError } from \"./schema/transitions\";\nimport { VersionConflictError } from \"./store/driver\";\nimport type { FactoryStores } from \"./store/engine\";\n\n/** Graph, receipt, repository, and Task capabilities required by queued-work dispatch. */\nexport type SweepQueuedStores = Pick<\n  FactoryStores,\n  \"graphs\" | \"receipts\" | \"repositories\" | \"tasks\"\n>;\n\n/**\n * Single-repository adapter for an exact agent route. Supplied by the app, which knows its\n * agents' addresses. Returns the provider's execution reference when it has one.\n */\nexport type TaskLauncher = (task: Task, repository: Repository) => Promise<ExecutionReference>;\n\n/** Exact-route launchers, budget gate, and pass bounds for queued Task dispatch. */\nexport interface SweepQueuedOptions {\n  /** Single-repository agent adapters keyed by routeKey(binding), e.g. code-change@1. */\n  launchers: Readonly<Partial<Record<AgentRouteKey, TaskLauncher>>>;\n  /** Reserve-before-execution limits, passed through to every dispatch. */\n  budget?: DispatchBudget;\n  /** Maximum task launches attempted in one pass; omitted means no limit. */\n  maxDispatches?: number;\n  /** A dispatcher-wide snapshot avoids another complete task read. */\n  tasks?: readonly Task[];\n}\n\n/** Tasks dispatched, deferred by a gate, or failed by one queued-work pass. */\nexport interface SweepQueuedResult {\n  readonly dispatched: readonly TaskId[];\n  /** Tasks left in the queue because a declared gate may become eligible later. */\n  readonly skipped: readonly {\n    readonly taskId: TaskId;\n    readonly reasonCode: SweepSkipReasonCode;\n    readonly reason: string;\n  }[];\n  /** Tasks whose routing is invalid or whose launch threw. */\n  readonly failed: readonly {\n    readonly taskId: TaskId;\n    readonly reasonCode: SweepFailureReasonCode;\n    readonly reason: string;\n  }[];\n}\n\n/** Stable reason a queued Task remained eligible for a later dispatch pass. */\nexport type SweepSkipReasonCode =\n  | DispatchRefusalCode\n  | \"workflow_owned\"\n  | \"awaiting_approval\"\n  | \"dispatch_limit\"\n  | \"task_changed\";\n\n/** Stable reason a queued Task could not be routed or launched. */\nexport type SweepFailureReasonCode =\n  | \"invalid_repository_scope\"\n  | \"repository_not_found\"\n  | \"launcher_not_registered\"\n  | \"launch_failed\";\n\ntype MutableSweepQueuedResult = {\n  dispatched: TaskId[];\n  skipped: { taskId: TaskId; reasonCode: SweepSkipReasonCode; reason: string }[];\n  failed: { taskId: TaskId; reasonCode: SweepFailureReasonCode; reason: string }[];\n};\n\nasync function failUnrouteable(\n  stores: SweepQueuedStores,\n  task: Task,\n  reasonCode: SweepFailureReasonCode,\n  reason: string,\n  result: MutableSweepQueuedResult,\n): Promise<void> {\n  try {\n    await stores.tasks.transition(task.id, \"failed\", { reason, expectFrom: \"queued\" });\n    result.failed.push({ taskId: task.id, reasonCode, reason });\n  } catch (error) {\n    if (error instanceof InvalidTransitionError || error instanceof VersionConflictError) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"task_changed\",\n        reason: \"task changed during routing\",\n      });\n      return;\n    }\n    throw error;\n  }\n}\n\n/**\n * One pass of the factory's dispatcher, meant to run on a schedule inside the\n * deployment: every queued task that is allowed to run is started, in\n * creation order. Nothing outside the factory ever starts an agent; the CLI\n * only writes tasks and approvals, and this picks them up.\n * Idempotent by construction: dispatchTask's single-winner transition means\n * two overlapping sweeps cannot start the same task twice.\n */\nexport async function sweepQueued(\n  stores: SweepQueuedStores,\n  options: SweepQueuedOptions,\n): Promise<SweepQueuedResult> {\n  const result: MutableSweepQueuedResult = { dispatched: [], skipped: [], failed: [] };\n  const maxDispatches = options.maxDispatches ?? Number.POSITIVE_INFINITY;\n  if (\n    !(Number.isInteger(maxDispatches) || maxDispatches === Number.POSITIVE_INFINITY) ||\n    maxDispatches < 1\n  ) {\n    throw new Error(\"maxDispatches must be a positive integer\");\n  }\n  let attempted = 0;\n  const taskSnapshot = options.tasks ?? (await stores.tasks.list());\n  const budgetSnapshot =\n    options.budget?.tasks ??\n    (options.budget && options.tasks ? await stores.tasks.list() : taskSnapshot);\n  const budgetTasks = new Map(budgetSnapshot.map((task) => [task.id, task]));\n  const queued = taskSnapshot\n    .filter((task) => task.state === \"queued\")\n    .sort((a, b) => b.attempt - a.attempt || a.createdAt.localeCompare(b.createdAt));\n\n  for (const task of queued) {\n    const route = task.work.route;\n    if (route === undefined) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"workflow_owned\",\n        reason: \"no agent route; workflow owns execution\",\n      });\n      continue;\n    }\n    const [repositoryId] = task.repositoryIds;\n    if (task.repositoryIds.length !== 1 || repositoryId === undefined) {\n      await failUnrouteable(\n        stores,\n        task,\n        \"invalid_repository_scope\",\n        \"sweep launcher adapter requires exactly one repository\",\n        result,\n      );\n      continue;\n    }\n    if (task.approval === \"required\") {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"awaiting_approval\",\n        reason: \"awaiting human approval\",\n      });\n      continue;\n    }\n    const key = routeKey(route);\n    const launcher = Object.hasOwn(options.launchers, key) ? options.launchers[key] : undefined;\n    if (launcher === undefined) {\n      await failUnrouteable(\n        stores,\n        task,\n        \"launcher_not_registered\",\n        `no registered launcher handles agent route ${key}`,\n        result,\n      );\n      continue;\n    }\n    if (\n      !(await stores.graphs.dependenciesSatisfied({\n        rootTaskId: task.rootTaskId,\n        taskId: task.id,\n      }))\n    ) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"dependencies_unsatisfied\",\n        reason: \"graph dependencies must all be succeeded before dispatch\",\n      });\n      continue;\n    }\n    if (attempted >= maxDispatches) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"dispatch_limit\",\n        reason: \"per-sweep dispatch limit reached\",\n      });\n      continue;\n    }\n    const repository = await stores.repositories.get(repositoryId);\n    if (repository === null) {\n      await failUnrouteable(stores, task, \"repository_not_found\", \"task has no repository\", result);\n      continue;\n    }\n    try {\n      const dispatched = await dispatchTask(stores, {\n        taskId: task.id,\n        route,\n        launch: (dispatched) => {\n          attempted += 1;\n          return launcher(dispatched, repository);\n        },\n        budget:\n          options.budget === undefined\n            ? undefined\n            : { ...options.budget, tasks: [...budgetTasks.values()] },\n      });\n      budgetTasks.set(dispatched.id, dispatched);\n      result.dispatched.push(task.id);\n    } catch (error) {\n      if (options.budget !== undefined) {\n        const current = await stores.tasks.get(task.id).catch(() => null);\n        if (current !== null) budgetTasks.set(current.id, current);\n      }\n      if (error instanceof DispatchRefusedError) {\n        // Dependencies not ready, or another sweep won the race. Leave it.\n        result.skipped.push({ taskId: task.id, reasonCode: error.code, reason: error.reason });\n        continue;\n      }\n      result.failed.push({\n        taskId: task.id,\n        reasonCode: \"launch_failed\",\n        reason: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"sweep.mjs","names":[],"sources":["../src/sweep.ts"],"sourcesContent":["import { routeKey, type AgentRouteKey } from \"./agent-routes\";\nimport { dispatchTask, DispatchRefusedError, type DispatchBudget } from \"./dispatch\";\nimport type { DispatchRefusalCode } from \"./dispatch\";\nimport type { TaskId } from \"./schema/id\";\nimport type { Repository } from \"./schema/repository\";\nimport type { ExecutionReference, Task } from \"./schema/task\";\nimport { InvalidTransitionError } from \"./schema/transitions\";\nimport { VersionConflictError } from \"./store/driver\";\nimport { TaskAttemptConflictError, type FactoryStores } from \"./store/engine\";\n\n/** Graph, receipt, repository, and Task capabilities required by queued-work dispatch. */\nexport type SweepQueuedStores = Pick<\n  FactoryStores,\n  \"graphs\" | \"receipts\" | \"repositories\" | \"tasks\"\n>;\n\n/**\n * Single-repository adapter for an exact agent route. Supplied by the app, which knows its\n * agents' addresses. Returns the provider's execution reference when it has one.\n *\n * @param task - Running Task already admitted by the dispatch gate.\n * @param repository - Exact enabled repository selected from the Task scope.\n * @returns Provider execution reference that dispatch can persist for recovery.\n */\nexport type TaskLauncher = (task: Task, repository: Repository) => Promise<ExecutionReference>;\n\n/** Exact-route launchers, budget gate, and pass bounds for queued Task dispatch. */\nexport interface SweepQueuedOptions {\n  /** Single-repository agent adapters keyed by routeKey(binding), e.g. code-change@1. */\n  launchers: Readonly<Partial<Record<AgentRouteKey, TaskLauncher>>>;\n  /** Reserve-before-execution limits, passed through to every dispatch. */\n  budget?: DispatchBudget;\n  /** Maximum task launches attempted in one pass; omitted means no limit. */\n  maxDispatches?: number;\n  /** A dispatcher-wide snapshot avoids another complete task read. */\n  tasks?: readonly Task[];\n}\n\n/** Tasks dispatched, deferred by a gate, or failed by one queued-work pass. */\nexport interface SweepQueuedResult {\n  /** Task IDs whose provider execution reference was durably recorded. */\n  readonly dispatched: readonly TaskId[];\n  /** Tasks left in the queue because a declared gate may become eligible later. */\n  readonly skipped: readonly {\n    readonly taskId: TaskId;\n    readonly reasonCode: SweepSkipReasonCode;\n    readonly reason: string;\n  }[];\n  /** Tasks whose routing is invalid or whose launch threw. */\n  readonly failed: readonly {\n    readonly taskId: TaskId;\n    readonly reasonCode: SweepFailureReasonCode;\n    readonly reason: string;\n  }[];\n}\n\n/** Stable reason a queued Task remained eligible for a later dispatch pass. */\nexport type SweepSkipReasonCode =\n  | DispatchRefusalCode\n  | \"workflow_owned\"\n  | \"awaiting_approval\"\n  | \"dispatch_limit\"\n  | \"task_changed\";\n\n/** Stable reason a queued Task could not be routed or launched. */\nexport type SweepFailureReasonCode =\n  | \"invalid_repository_scope\"\n  | \"repository_not_found\"\n  | \"launcher_not_registered\"\n  | \"launch_failed\";\n\ntype MutableSweepQueuedResult = {\n  dispatched: TaskId[];\n  skipped: { taskId: TaskId; reasonCode: SweepSkipReasonCode; reason: string }[];\n  failed: { taskId: TaskId; reasonCode: SweepFailureReasonCode; reason: string }[];\n};\n\nasync function failUnrouteable(\n  stores: SweepQueuedStores,\n  task: Task,\n  reasonCode: SweepFailureReasonCode,\n  reason: string,\n  result: MutableSweepQueuedResult,\n): Promise<void> {\n  try {\n    await stores.tasks.transition(task.id, \"failed\", { reason, expectFrom: \"queued\" });\n    result.failed.push({ taskId: task.id, reasonCode, reason });\n  } catch (error) {\n    if (error instanceof InvalidTransitionError || error instanceof VersionConflictError) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"task_changed\",\n        reason: \"task changed during routing\",\n      });\n      return;\n    }\n    throw error;\n  }\n}\n\n/**\n * Runs one bounded pass over queued Tasks and dispatches each eligible exact route.\n *\n * @remarks\n * Candidates are ordered by newest attempt first and then creation time. Route-less work remains\n * queued for its workflow owner; unmet dependencies, approvals, and pass limits appear in\n * `skipped`. Invalid repository scope, missing repositories or launchers, and launch failures\n * appear in `failed`, with unrouteable Tasks transitioned to `failed` when this sweep wins the\n * race. A result entry describes this pass rather than guaranteeing the Task's lifecycle state:\n * an ambiguously accepted launch is reported as `launch_failed` while its Task intentionally stays\n * running for recovery. Callers should surface every failure, reread those Tasks before deciding\n * remediation, and schedule another pass for skipped work.\n *\n * Overlapping passes are safe: {@link dispatchTask} atomically admits one winner before invoking a\n * launcher. A supplied `tasks` snapshot bounds reads and candidate selection for this pass; it can\n * become stale, and corresponding races are returned as `task_changed` rather than hidden.\n * `maxDispatches` counts provider launches started during the pass, including launches that later\n * fail, so `dispatched.length` may be smaller than the limit.\n *\n * @param stores - Graph, receipt, repository, and Task stores used during the pass.\n * @param options - Exact-route launchers plus optional budget, Task snapshot, and dispatch limit.\n * @returns IDs dispatched and structured skipped/failed outcomes for every considered candidate.\n * @throws When `maxDispatches` is not a positive integer or an unexpected persistence error occurs.\n * @see The shipped `docs/recipes/retry-recovery.md` recipe for scheduled recovery.\n */\nexport async function sweepQueued(\n  stores: SweepQueuedStores,\n  options: SweepQueuedOptions,\n): Promise<SweepQueuedResult> {\n  const result: MutableSweepQueuedResult = { dispatched: [], skipped: [], failed: [] };\n  const maxDispatches = options.maxDispatches ?? Number.POSITIVE_INFINITY;\n  if (\n    !(Number.isInteger(maxDispatches) || maxDispatches === Number.POSITIVE_INFINITY) ||\n    maxDispatches < 1\n  ) {\n    throw new Error(\"maxDispatches must be a positive integer\");\n  }\n  let attempted = 0;\n  const taskSnapshot = options.tasks ?? (await stores.tasks.list());\n  const budgetSnapshot =\n    options.budget?.tasks ??\n    (options.budget && options.tasks ? await stores.tasks.list() : taskSnapshot);\n  const budgetTasks = new Map(budgetSnapshot.map((task) => [task.id, task]));\n  const queued = taskSnapshot\n    .filter((task) => task.state === \"queued\")\n    .sort((a, b) => b.attempt - a.attempt || a.createdAt.localeCompare(b.createdAt));\n\n  for (const task of queued) {\n    const route = task.work.route;\n    if (route === undefined) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"workflow_owned\",\n        reason: \"no agent route; workflow owns execution\",\n      });\n      continue;\n    }\n    const [repositoryId] = task.repositoryIds;\n    if (task.repositoryIds.length !== 1 || repositoryId === undefined) {\n      await failUnrouteable(\n        stores,\n        task,\n        \"invalid_repository_scope\",\n        \"sweep launcher adapter requires exactly one repository\",\n        result,\n      );\n      continue;\n    }\n    if (task.approval === \"required\") {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"awaiting_approval\",\n        reason: \"awaiting human approval\",\n      });\n      continue;\n    }\n    const key = routeKey(route);\n    const launcher = Object.hasOwn(options.launchers, key) ? options.launchers[key] : undefined;\n    if (launcher === undefined) {\n      await failUnrouteable(\n        stores,\n        task,\n        \"launcher_not_registered\",\n        `no registered launcher handles agent route ${key}`,\n        result,\n      );\n      continue;\n    }\n    if (\n      !(await stores.graphs.dependenciesSatisfied({\n        rootTaskId: task.rootTaskId,\n        taskId: task.id,\n      }))\n    ) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"dependencies_unsatisfied\",\n        reason: \"graph dependencies must all be succeeded before dispatch\",\n      });\n      continue;\n    }\n    if (attempted >= maxDispatches) {\n      result.skipped.push({\n        taskId: task.id,\n        reasonCode: \"dispatch_limit\",\n        reason: \"per-sweep dispatch limit reached\",\n      });\n      continue;\n    }\n    const repository = await stores.repositories.get(repositoryId);\n    if (repository === null) {\n      await failUnrouteable(stores, task, \"repository_not_found\", \"task has no repository\", result);\n      continue;\n    }\n    let launchStarted = false;\n    try {\n      const dispatched = await dispatchTask(stores, {\n        taskId: task.id,\n        route,\n        launch: (dispatched) => {\n          attempted += 1;\n          launchStarted = true;\n          return launcher(dispatched, repository);\n        },\n        budget:\n          options.budget === undefined\n            ? undefined\n            : { ...options.budget, tasks: [...budgetTasks.values()] },\n      });\n      budgetTasks.set(dispatched.id, dispatched);\n      result.dispatched.push(task.id);\n    } catch (error) {\n      if (options.budget !== undefined) {\n        const current = await stores.tasks.get(task.id).catch(() => null);\n        if (current !== null) budgetTasks.set(current.id, current);\n      }\n      if (error instanceof DispatchRefusedError) {\n        // Dependencies not ready, or another sweep won the race. Leave it.\n        result.skipped.push({ taskId: task.id, reasonCode: error.code, reason: error.reason });\n        continue;\n      }\n      if (\n        !launchStarted &&\n        (error instanceof InvalidTransitionError ||\n          error instanceof TaskAttemptConflictError ||\n          error instanceof VersionConflictError)\n      ) {\n        result.skipped.push({\n          taskId: task.id,\n          reasonCode: \"task_changed\",\n          reason: \"task changed before dispatch\",\n        });\n        continue;\n      }\n      result.failed.push({\n        taskId: task.id,\n        reasonCode: \"launch_failed\",\n        reason: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/dist/task-graph-view.d.mts

@@ -13,6 +13,7 @@ declare const taskGraphViewSchema: z.ZodObject<{
       id: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
       repositoryIds: z.ZodReadonly<z.ZodTuple<[z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>], z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>>>;
       kind: z.ZodType<TaskKind, unknown, z.core.$ZodTypeInternals<TaskKind, unknown>>;
+      model: z.ZodOptional<z.ZodString>;
       area: z.ZodOptional<z.ZodString>;
       state: z.ZodEnum<{
         queued: "queued";
@@ -129,6 +130,7 @@ declare const taskGraphViewSchema: z.ZodObject<{
       attempt: number;
       createdAt: string;
       updatedAt: string;
+      model?: string | undefined;
       area?: string | undefined;
       approval?: "required" | "granted" | "denied" | undefined;
       workResult?: {
@@ -206,6 +208,7 @@ declare const taskGraphViewSchema: z.ZodObject<{
       attempt: number;
       createdAt: string;
       updatedAt: string;
+      model?: string | undefined;
       area?: string | undefined;
       approval?: "required" | "granted" | "denied" | undefined;
       workResult?: {

package/dist/tasks.d.mts

@@ -7,11 +7,11 @@ import { MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, TaskGraph, TaskGraph
 import { AdmitTaskGraphInput, AssertTaskAdmissionInput, CreateTaskGraphStoreOptions, SetTaskGraphDependenciesInput, TaskGraphConflictError, TaskGraphNodeRef, TaskGraphStore, assertTaskAdmission, createTaskGraphStore } from "./store/task-graphs.mjs";
 import { TaskEffect, TaskEffectKey, TaskEffectReference, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema } from "./schema/task-effect.mjs";
 import { CreateTaskEffectStoreOptions, RecordTaskEffectInput, ResolveTaskEffectInput, TaskEffectLookupInput, TaskEffectStore, createTaskEffectStore } from "./store/task-effects.mjs";
-import { CompleteTaskWorkInput, CompleteWorkflowTaskWorkInput, CreateTaskWorkStoreOptions, ResumeTaskWorkInput, TaskWorkStore, TaskWorkStores, TaskWorkUsage, WaitForTaskMessagesInput, createTaskWorkStore } from "./store/task-work.mjs";
+import { CompleteTaskWorkInput, CompleteWorkflowTaskWorkInput, CreateTaskWorkStoreOptions, ResumeTaskWorkInput, TaskWorkCompletionFence, TaskWorkStore, TaskWorkStores, TaskWorkUsage, WaitForTaskMessagesInput, createTaskWorkStore } from "./store/task-work.mjs";
 import { AnswerEvent, answerEventSchema } from "./schema/answer.mjs";
-import { AgentSessionBinding, AnswerEventConflictError, AnswerQuestionInput, AnswerQuestionResult, ApprovalDecision, ApprovalError, CreateTaskInput, RejectionDecision, RootTaskOrigin, TaskPatch, TaskTransitionArguments, TaskTransitionOptions } from "./store/engine.mjs";
+import { AgentSessionBinding, AnswerEventConflictError, AnswerQuestionInput, AnswerQuestionResult, ApprovalDecision, ApprovalError, CreateTaskInput, RejectionDecision, RootTaskOrigin, TaskAttemptConflictError, TaskPatch, TaskTransitionArguments, TaskTransitionOptions } from "./store/engine.mjs";
 import { ApprovalAccess, ApprovalAccessDecisionInput, ApprovalAccessError, ApprovalAccessOptions, ApprovalAccessStores, createApprovalAccess } from "./approval-access.mjs";
 import { taskInitialState, taskTransitions } from "./schema/transitions.mjs";
 import { ProcessTaskMessageOptions, ProcessTaskMessageResult, TaskMessageProcessingStores, processTaskMessage, readTaskMessageDecision } from "./task-message-processing.mjs";
 import { AssignmentPayload, DefaultTaskMessageProtocols, HandoffPayload, StandardTaskMessageProtocol, assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols } from "./task-protocols.mjs";
-export { type AdmitTaskGraphInput, type AgentSessionBinding, type AnswerEvent, AnswerEventConflictError, type AnswerId, type AnswerQuestionInput, type AnswerQuestionResult, type ApprovalAccess, type ApprovalAccessDecisionInput, ApprovalAccessError, type ApprovalAccessOptions, type ApprovalAccessStores, type ApprovalDecision, ApprovalError, type ApprovalPolicy, type ApprovalPriority, type ApprovalRule, type ApprovalSubject, type AssertTaskAdmissionInput, type AssertTaskMessageClaimInput, type AssignmentPayload, type ClaimTaskMessageInput, type ClaimTaskMessageResult, type CompleteTaskMessageInput, type CompleteTaskWorkInput, type CompleteWorkflowTaskWorkInput, type CreateTaskEffectStoreOptions, type CreateTaskGraphStoreOptions, type CreateTaskInput, type CreateTaskMessageStoreOptions, type CreateTaskWorkStoreOptions, type DefaultTaskMessageProtocols, type DiscardTaskMessageInput, type ExecutionReference, type HandoffPayload, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, type MessageWaitingTask, type NeedsHumanTask, type ProcessTaskMessageOptions, type ProcessTaskMessageResult, type RecordTaskEffectInput, type RejectionDecision, type ResolveTaskEffectInput, type ResumeTaskWorkInput, type RootTaskOrigin, type SendTaskMessageInput, type SetTaskGraphDependenciesInput, type StandardTaskMessageProtocol, type SucceededTask, type Task, type TaskApproval, type TaskEffect, type TaskEffectKey, type TaskEffectLookupInput, type TaskEffectReference, type TaskEffectStore, type TaskGraph, TaskGraphConflictError, type TaskGraphNode, type TaskGraphNodeRef, type TaskGraphStore, type TaskId, type TaskInbox, type TaskKind, type TaskMessage, type TaskMessageAction, TaskMessageAuthorizationError, type TaskMessageAuthorizationInput, type TaskMessageAuthorize, type TaskMessageClaim, TaskMessageConflictError, type TaskMessageDiscard, type TaskMessageEffectKeyInput, TaskMessageError, type TaskMessageForProtocol, type TaskMessageId, TaskMessageLeaseError, type TaskMessageLookupInput, type TaskMessageOperationId, type TaskMessagePrincipal, type TaskMessageProcessing, type TaskMessageProcessingStores, type TaskMessageProtocol, type TaskMessageProtocolBinding, type TaskMessageProtocolBindingInput, type TaskMessageProtocolInput, type TaskMessageProtocolInputPayload, type TaskMessageProtocolStoredPayload, type TaskMessageProtocols, type TaskMessageRecipientInput, type TaskMessageSendInput, TaskMessageSourceFenceError, type TaskMessageStore, type TaskOrigin, type TaskPatch, type TaskQuestion, type TaskState, type TaskTransitionArguments, type TaskTransitionOptions, type TaskUsage, type TaskWorkStore, type TaskWorkStores, type TaskWorkUsage, type WaitForTaskMessagesInput, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };
+export { type AdmitTaskGraphInput, type AgentSessionBinding, type AnswerEvent, AnswerEventConflictError, type AnswerId, type AnswerQuestionInput, type AnswerQuestionResult, type ApprovalAccess, type ApprovalAccessDecisionInput, ApprovalAccessError, type ApprovalAccessOptions, type ApprovalAccessStores, type ApprovalDecision, ApprovalError, type ApprovalPolicy, type ApprovalPriority, type ApprovalRule, type ApprovalSubject, type AssertTaskAdmissionInput, type AssertTaskMessageClaimInput, type AssignmentPayload, type ClaimTaskMessageInput, type ClaimTaskMessageResult, type CompleteTaskMessageInput, type CompleteTaskWorkInput, type CompleteWorkflowTaskWorkInput, type CreateTaskEffectStoreOptions, type CreateTaskGraphStoreOptions, type CreateTaskInput, type CreateTaskMessageStoreOptions, type CreateTaskWorkStoreOptions, type DefaultTaskMessageProtocols, type DiscardTaskMessageInput, type ExecutionReference, type HandoffPayload, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, type MessageWaitingTask, type NeedsHumanTask, type ProcessTaskMessageOptions, type ProcessTaskMessageResult, type RecordTaskEffectInput, type RejectionDecision, type ResolveTaskEffectInput, type ResumeTaskWorkInput, type RootTaskOrigin, type SendTaskMessageInput, type SetTaskGraphDependenciesInput, type StandardTaskMessageProtocol, type SucceededTask, type Task, type TaskApproval, TaskAttemptConflictError, type TaskEffect, type TaskEffectKey, type TaskEffectLookupInput, type TaskEffectReference, type TaskEffectStore, type TaskGraph, TaskGraphConflictError, type TaskGraphNode, type TaskGraphNodeRef, type TaskGraphStore, type TaskId, type TaskInbox, type TaskKind, type TaskMessage, type TaskMessageAction, TaskMessageAuthorizationError, type TaskMessageAuthorizationInput, type TaskMessageAuthorize, type TaskMessageClaim, TaskMessageConflictError, type TaskMessageDiscard, type TaskMessageEffectKeyInput, TaskMessageError, type TaskMessageForProtocol, type TaskMessageId, TaskMessageLeaseError, type TaskMessageLookupInput, type TaskMessageOperationId, type TaskMessagePrincipal, type TaskMessageProcessing, type TaskMessageProcessingStores, type TaskMessageProtocol, type TaskMessageProtocolBinding, type TaskMessageProtocolBindingInput, type TaskMessageProtocolInput, type TaskMessageProtocolInputPayload, type TaskMessageProtocolStoredPayload, type TaskMessageProtocols, type TaskMessageRecipientInput, type TaskMessageSendInput, TaskMessageSourceFenceError, type TaskMessageStore, type TaskOrigin, type TaskPatch, type TaskQuestion, type TaskState, type TaskTransitionArguments, type TaskTransitionOptions, type TaskUsage, type TaskWorkCompletionFence, type TaskWorkStore, type TaskWorkStores, type TaskWorkUsage, type WaitForTaskMessagesInput, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };

package/dist/tasks.mjs

@@ -1,6 +1,6 @@
 import { answerIdSchema, taskIdSchema } from "./schema/id.mjs";
-import { allowByDefaultApprovalPolicy, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, requiresApproval } from "./approval.mjs";
 import { executionReferenceSchema, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, standardTaskKinds, taskApprovalSchema, taskExecutionRepositoryIdsSchema, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskUsageSchema } from "./schema/task.mjs";
+import { allowByDefaultApprovalPolicy, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, requiresApproval } from "./approval.mjs";
 import { taskInitialState, taskTransitions } from "./schema/transitions.mjs";
 import { ApprovalAccessError, createApprovalAccess } from "./approval-access.mjs";
 import { answerEventSchema } from "./schema/answer.mjs";
@@ -13,5 +13,5 @@ import { createTaskWorkStore } from "./store/task-work.mjs";
 import { createTaskEffectStore } from "./store/task-effects.mjs";
 import { processTaskMessage, readTaskMessageDecision } from "./task-message-processing.mjs";
 import { assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols } from "./task-protocols.mjs";
-import { AnswerEventConflictError, ApprovalError } from "./store/engine.mjs";
-export { AnswerEventConflictError, ApprovalAccessError, ApprovalError, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, TaskGraphConflictError, TaskMessageAuthorizationError, TaskMessageConflictError, TaskMessageError, TaskMessageLeaseError, TaskMessageSourceFenceError, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };
+import { AnswerEventConflictError, ApprovalError, TaskAttemptConflictError } from "./store/engine.mjs";
+export { AnswerEventConflictError, ApprovalAccessError, ApprovalError, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, TaskAttemptConflictError, TaskGraphConflictError, TaskMessageAuthorizationError, TaskMessageConflictError, TaskMessageError, TaskMessageLeaseError, TaskMessageSourceFenceError, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };

package/dist/vercel-git.d.mts

@@ -1,7 +1,27 @@
 import { RepositorySlug } from "./schema/repository.mjs";
 import { GitHubGitTransport } from "./github-transfer.mjs";
-import { Sandbox } from "@vercel/sandbox";
+import { NetworkPolicy, Sandbox } from "@vercel/sandbox";
 //#region src/vercel-git.d.ts
+type TrustedGitSandbox = Pick<Sandbox, "cwd" | "runCommand" | "writeFiles" | "readFile" | "updateNetworkPolicy" | "stop">;
+/** Exact creation request for a fresh Vercel-managed trusted Git publication Sandbox. */
+interface VercelManagedGitHubSandboxCreateInput {
+  source: {
+    type: "git";
+    url: string;
+  };
+  __source_credentials: true;
+  __commitAs: {
+    name: string;
+    email: string;
+  };
+  networkPolicy: NetworkPolicy;
+  persistent: false;
+  resources: {
+    vcpus: 6;
+  };
+  runtime: "node24";
+  timeout: number;
+}
 /** Repository and access level used to mint one trusted Git transport token. */
 interface VercelGitHubTokenInput {
   repository: RepositorySlug;
@@ -12,10 +32,22 @@ interface VercelGitHubGitTransportOptions {
   /** Reads must mint contents:read credentials; writes are confined to the supplied repository. */
   token(input: VercelGitHubTokenInput): Promise<string>;
   /** Creates a fresh sandbox, without a snapshot, repository, or running agent. */
-  createSandbox?: () => Promise<Pick<Sandbox, "runCommand" | "writeFiles" | "readFileToBuffer" | "updateNetworkPolicy" | "stop">>;
+  createSandbox?: () => Promise<TrustedGitSandbox>;
+}
+/** Configures Vercel-managed Git reads and signed publication. */
+interface VercelManagedGitHubGitTransportOptions {
+  /** Attribution metadata supplied for managed signed commits. */
+  commitIdentity: {
+    name: string;
+    email: string;
+  };
+  /** Creates one unnamed Sandbox from the exact managed credential request. */
+  createSandbox?: (input: VercelManagedGitHubSandboxCreateInput) => Promise<TrustedGitSandbox>;
 }
 /** Transfer Git objects through fresh trusted sandboxes; credentials never reach an agent sandbox. */
 declare function createVercelGitHubGitTransport(options: VercelGitHubGitTransportOptions): GitHubGitTransport;
+/** Use fresh Vercel-managed trusted Sandboxes for Git reads and signed publication. */
+declare function createVercelManagedGitHubGitTransport(options: VercelManagedGitHubGitTransportOptions): GitHubGitTransport;
 //#endregion
-export { VercelGitHubGitTransportOptions, VercelGitHubTokenInput, createVercelGitHubGitTransport };
+export { VercelGitHubGitTransportOptions, VercelGitHubTokenInput, VercelManagedGitHubGitTransportOptions, VercelManagedGitHubSandboxCreateInput, createVercelGitHubGitTransport, createVercelManagedGitHubGitTransport };
 //# sourceMappingURL=vercel-git.d.mts.map

package/dist/vercel-git.mjs

@@ -1,7 +1,80 @@
 import { repositorySlugSchema } from "./schema/repository.mjs";
-import { validateGitBundle } from "./github-transfer.mjs";
+import { withSandboxGitBundle } from "./github-transfer.mjs";
 import { isSafeGitRef } from "./github-publication.mjs";
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
 //#region src/vercel-git.ts
+const gitOidPattern = /^[a-f0-9]{40}$/u;
+const absentGitOid = "0".repeat(40);
+const managedGitTimeoutMs = 18e4;
+async function createManagedSandbox(input) {
+	const { Sandbox } = await import("@vercel/sandbox");
+	return Sandbox.create({ ...input });
+}
+function publicationBase(input) {
+	if (!isSafeGitRef(input.branch) || !gitOidPattern.test(input.head) || !gitOidPattern.test(input.expectedHead) || (input.expectedHead === absentGitOid ? input.baseHead === void 0 || !gitOidPattern.test(input.baseHead) : input.baseHead !== void 0)) throw new Error("Invalid Git publication target");
+	return input.expectedHead === absentGitOid ? input.baseHead : input.expectedHead;
+}
+async function trustedCommand(sandbox, input) {
+	const result = await sandbox.runCommand({
+		...input,
+		timeoutMs: 12e4
+	});
+	if (result.exitCode !== 0) throw new Error(`Trusted Git operation failed (${result.exitCode})`);
+	return (await result.stdout()).trim();
+}
+function bundleTransferSandbox(sandbox) {
+	return {
+		async run({ command }) {
+			const result = await sandbox.runCommand({
+				cmd: "sh",
+				args: ["-c", command]
+			});
+			return {
+				exitCode: result.exitCode,
+				stdout: await result.stdout()
+			};
+		},
+		async writeBinaryFile({ path, content }) {
+			await sandbox.writeFiles([{
+				path,
+				content: Buffer.from(content.buffer, content.byteOffset, content.byteLength)
+			}]);
+		}
+	};
+}
+async function consumeSandboxBundle(sandbox, path, use) {
+	const size = await sandbox.runCommand({
+		cmd: "stat",
+		args: [
+			"-c",
+			"%s",
+			path
+		]
+	});
+	const byteLength = Number(await size.stdout());
+	if (size.exitCode !== 0 || !Number.isSafeInteger(byteLength) || byteLength < 1 || byteLength > 314572800) throw new Error("Git bundle exceeds transfer limit");
+	const source = await sandbox.readFile({ path });
+	if (!source) throw new Error("Git bundle was not created");
+	const readable = source instanceof Readable ? source : new Readable({ highWaterMark: 65536 }).wrap(source);
+	const iterator = readable[Symbol.asyncIterator]();
+	const stream = new ReadableStream({
+		async pull(controller) {
+			const { done, value } = await iterator.next();
+			if (done) controller.close();
+			else controller.enqueue(value);
+		},
+		async cancel() {
+			await iterator.return?.();
+		}
+	}, { highWaterMark: 0 });
+	try {
+		await use({ stream });
+	} finally {
+		readable.destroy();
+		if (!stream.locked) await stream.cancel();
+	}
+}
 function credentialPolicy(repository, token) {
 	return { allow: { "github.com": [{
 		match: { path: { startsWith: `/${repository}.git/` } },
@@ -57,7 +130,7 @@ function createVercelGitHubGitTransport(options) {
 		}
 	}
 	return {
-		async fetch(input) {
+		async fetch(input, use) {
 			if (input.refs.some((ref) => !ref.startsWith("refs/") || !isSafeGitRef(ref))) throw new Error("Invalid Git fetch ref");
 			return isolated(input.repository, async (sandbox, git, slug) => {
 				await sandbox.updateNetworkPolicy(credentialPolicy(slug, await options.token({
@@ -68,45 +141,204 @@ function createVercelGitHubGitTransport(options) {
 				if (input.refs.length) await git("-C", "/tmp/transfer.git", "fetch", "--no-tags", "origin", ...input.refs.map((ref) => `+${ref}:${ref}`));
 				await sandbox.updateNetworkPolicy("deny-all");
 				await git("-C", "/tmp/transfer.git", "bundle", "create", "/tmp/transfer.bundle", "--all");
-				const size = await sandbox.runCommand({
-					cmd: "stat",
+				await consumeSandboxBundle(sandbox, "/tmp/transfer.bundle", use);
+			});
+		},
+		async push(input) {
+			try {
+				const baseHead = publicationBase(input);
+				return await isolated(input.repository, async (sandbox, git, slug) => {
+					await git("init", "--bare", "/tmp/transfer.git");
+					return await withSandboxGitBundle({
+						sandbox: bundleTransferSandbox(sandbox),
+						bundle: input.bundle,
+						async use(path) {
+							await git("-C", "/tmp/transfer.git", "bundle", "verify", path);
+							await git("-C", "/tmp/transfer.git", "fetch", path, "HEAD:refs/heads/candidate");
+							if (await git("-C", "/tmp/transfer.git", "rev-parse", "refs/heads/candidate") !== input.head) throw new Error("Git bundle head does not match publication target");
+							await git("-C", "/tmp/transfer.git", "merge-base", "--is-ancestor", baseHead, "refs/heads/candidate");
+							await sandbox.updateNetworkPolicy(credentialPolicy(slug, await options.token({
+								repository: slug,
+								access: "write"
+							})));
+							await input.authorize();
+							await git("-C", "/tmp/transfer.git", "push", `--force-with-lease=refs/heads/${input.branch}:${input.expectedHead}`, `https://github.com/${slug}.git`, `${input.head}:refs/heads/${input.branch}`);
+							return input.head;
+						}
+					});
+				});
+			} finally {
+				if (!input.bundle.stream.locked) await input.bundle.stream.cancel();
+			}
+		}
+	};
+}
+/** Use fresh Vercel-managed trusted Sandboxes for Git reads and signed publication. */
+function createVercelManagedGitHubGitTransport(options) {
+	const createSandbox = options.createSandbox ?? createManagedSandbox;
+	const createInput = (repository, access) => ({
+		source: {
+			type: "git",
+			url: `https://github.com/${repository}.git`
+		},
+		__source_credentials: true,
+		__commitAs: options.commitIdentity,
+		networkPolicy: { allow: access === "read" ? ["github.com"] : ["github.com", "api.github.com"] },
+		persistent: false,
+		resources: { vcpus: 6 },
+		runtime: "node24",
+		timeout: managedGitTimeoutMs
+	});
+	return {
+		async fetch(input, use) {
+			if (input.refs.some((ref) => !ref.startsWith("refs/") || !isSafeGitRef(ref))) throw new Error("Invalid Git fetch ref");
+			const repository = repositorySlugSchema.parse(input.repository.toLowerCase());
+			const sandbox = await createSandbox(createInput(repository, "read"));
+			const repositoryPath = sandbox.cwd;
+			try {
+				await trustedCommand(sandbox, {
+					cmd: "/usr/bin/git",
 					args: [
-						"-c",
-						"%s",
-						"/tmp/transfer.bundle"
+						"clone",
+						"--bare",
+						"--no-local",
+						repositoryPath,
+						"/tmp/transfer.git"
 					]
 				});
-				const byteLength = Number(await size.stdout());
-				if (size.exitCode !== 0 || !Number.isSafeInteger(byteLength) || byteLength < 1 || byteLength > 52428800) throw new Error("Git bundle exceeds transfer limit");
-				const data = await sandbox.readFileToBuffer({ path: "/tmp/transfer.bundle" });
-				if (!data || data.length > 52428800) throw new Error("Invalid Git bundle size");
-				const bundle = { base64: data.toString("base64") };
-				validateGitBundle(bundle);
-				return bundle;
-			});
+				if (input.refs.length > 0) await trustedCommand(sandbox, {
+					cmd: "git",
+					args: [
+						"-C",
+						"/tmp/transfer.git",
+						"fetch",
+						"--no-tags",
+						`https://github.com/${repository}.git`,
+						...input.refs.map((ref) => `+${ref}:${ref}`)
+					]
+				});
+				await trustedCommand(sandbox, {
+					cmd: "/usr/bin/git",
+					args: [
+						"-C",
+						"/tmp/transfer.git",
+						"bundle",
+						"create",
+						"/tmp/transfer.bundle",
+						"--all"
+					]
+				});
+				await consumeSandboxBundle(sandbox, "/tmp/transfer.bundle", use);
+			} finally {
+				await sandbox.stop();
+			}
 		},
 		async push(input) {
-			if (!isSafeGitRef(input.branch) || !/^[a-f0-9]{40}$/.test(input.head) || !/^[a-f0-9]{40}$/.test(input.expectedHead)) throw new Error("Invalid Git publication target");
-			const bundle = validateGitBundle(input.bundle);
-			await isolated(input.repository, async (sandbox, git, slug) => {
-				await git("init", "--bare", "/tmp/transfer.git");
-				await sandbox.writeFiles([{
-					path: "/tmp/transfer.bundle",
-					content: bundle
-				}]);
-				await git("-C", "/tmp/transfer.git", "bundle", "verify", "/tmp/transfer.bundle");
-				await git("-C", "/tmp/transfer.git", "fetch", "/tmp/transfer.bundle", "HEAD:refs/heads/candidate");
-				if (await git("-C", "/tmp/transfer.git", "rev-parse", "refs/heads/candidate") !== input.head) throw new Error("Git bundle head does not match publication target");
-				await sandbox.updateNetworkPolicy(credentialPolicy(slug, await options.token({
-					repository: slug,
-					access: "write"
-				})));
-				await git("-C", "/tmp/transfer.git", "push", `--force-with-lease=refs/heads/${input.branch}:${input.expectedHead}`, `https://github.com/${slug}.git`, `${input.head}:refs/heads/${input.branch}`);
-			});
+			try {
+				const baseHead = publicationBase(input);
+				if (input.expectedHead === absentGitOid) throw new Error("Vercel-managed signed publication requires an existing remote branch");
+				const repository = repositorySlugSchema.parse(input.repository.toLowerCase());
+				const sandbox = await createSandbox(createInput(repository, "write"));
+				const repositoryPath = sandbox.cwd;
+				try {
+					const hooksPath = `/tmp/factory-hooks-${randomUUID()}`;
+					await trustedCommand(sandbox, {
+						cmd: "mkdir",
+						args: [
+							"-m",
+							"700",
+							hooksPath
+						]
+					});
+					await trustedCommand(sandbox, {
+						cmd: "/usr/bin/git",
+						args: [
+							"config",
+							"core.hooksPath",
+							hooksPath
+						],
+						cwd: repositoryPath
+					});
+					await withSandboxGitBundle({
+						sandbox: bundleTransferSandbox(sandbox),
+						bundle: input.bundle,
+						async use(path) {
+							await trustedCommand(sandbox, {
+								cmd: "/usr/bin/git",
+								args: [
+									"bundle",
+									"verify",
+									path
+								],
+								cwd: repositoryPath
+							});
+							await trustedCommand(sandbox, {
+								cmd: "/usr/bin/git",
+								args: [
+									"fetch",
+									"--no-tags",
+									path,
+									`${input.head}:refs/factory/candidate`
+								],
+								cwd: repositoryPath
+							});
+							if (await trustedCommand(sandbox, {
+								cmd: "/usr/bin/git",
+								args: ["rev-parse", "refs/factory/candidate"],
+								cwd: repositoryPath
+							}) !== input.head) throw new Error("Git bundle head does not match publication target");
+							await trustedCommand(sandbox, {
+								cmd: "/usr/bin/git",
+								args: [
+									"merge-base",
+									"--is-ancestor",
+									baseHead,
+									"refs/factory/candidate"
+								],
+								cwd: repositoryPath
+							});
+							await trustedCommand(sandbox, {
+								cmd: "/usr/bin/git",
+								args: [
+									"checkout",
+									"-B",
+									input.branch,
+									"refs/factory/candidate"
+								],
+								cwd: repositoryPath
+							});
+							await input.authorize();
+							await trustedCommand(sandbox, {
+								cmd: "/usr/bin/env",
+								args: [
+									`VERCEL_GIT_EXPECTED_REMOTE_OID=${input.expectedHead}`,
+									...input.baseHead === void 0 ? [] : [`VERCEL_GIT_BASE_OID=${input.baseHead}`],
+									"git",
+									"push",
+									"origin",
+									input.branch
+								],
+								cwd: repositoryPath
+							});
+						}
+					});
+					const signedHead = await trustedCommand(sandbox, {
+						cmd: "/usr/bin/git",
+						args: ["rev-parse", "HEAD"],
+						cwd: repositoryPath
+					});
+					if (!gitOidPattern.test(signedHead)) throw new Error("Managed signed push returned an invalid Git head");
+					return signedHead;
+				} finally {
+					await sandbox.stop();
+				}
+			} finally {
+				if (!input.bundle.stream.locked) await input.bundle.stream.cancel();
+			}
 		}
 	};
 }
 //#endregion
-export { createVercelGitHubGitTransport };
+export { createVercelGitHubGitTransport, createVercelManagedGitHubGitTransport };
 
 //# sourceMappingURL=vercel-git.mjs.map