@drisp/protocol 0.8.6 → 0.8.8

package/dist/v2.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HMYWICNI.js";
 
 // src/v2.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/history.ts
 function readableHistory(records) {
@@ -73,8 +73,8 @@ function attemptForecast(declaredCap) {
 }
 function attemptCost(attempt) {
   const forecast = attemptForecast(attempt.tokenCap);
-  if (attempt.closed) return attempt.spent ?? forecast;
-  return Math.max(forecast, attempt.spent ?? 0);
+  const cost = attempt.closed ? attempt.spent ?? forecast : Math.max(forecast, attempt.spent ?? 0);
+  return attempt.tokenCap > 0 ? Math.min(attempt.tokenCap, cost) : cost;
 }
 function budgetCheck(input) {
   const used = input.attempts.reduce((sum, attempt) => sum + attemptCost(attempt), 0);
@@ -110,6 +110,192 @@ function forecastOfClass(sizeClass, calibration) {
   return calibration?.[sizeClass]?.forecast ?? SIZE_CLASS_FORECASTS[sizeClass];
 }
 
+// src/tracker.ts
+import { z as z2 } from "zod";
+var id = z2.string().min(1).max(160);
+var text = z2.string().max(1e5);
+var deliveryEvidenceKindSchema = z2.enum(["pr_opened", "merged", "staging", "qa_started", "qa_passed", "released"]);
+var deliveryStageSchema = z2.strictObject({
+  id,
+  name: z2.string().trim().min(1).max(100),
+  category: z2.enum(["backlog", "unstarted", "started", "completed", "canceled"]),
+  behavior: z2.enum(["manual", "agent_start", ...deliveryEvidenceKindSchema.options]).default("manual")
+});
+var deliveryTransitionSchema = z2.strictObject({
+  from: id,
+  to: id,
+  requires: z2.array(deliveryEvidenceKindSchema).default([])
+});
+var deliveryWorkflowSchema = z2.strictObject({
+  revision: z2.number().int().nonnegative(),
+  stages: z2.array(deliveryStageSchema).min(1).max(100),
+  transitions: z2.array(deliveryTransitionSchema).max(1e4),
+  attentionColumn: z2.boolean().default(true)
+}).superRefine((workflow, ctx) => {
+  const ids = new Set(workflow.stages.map((s) => s.id));
+  if (ids.size !== workflow.stages.length) ctx.addIssue({ code: "custom", message: "Duplicate stage ID" });
+  const edges = /* @__PURE__ */ new Set();
+  for (const edge of workflow.transitions) {
+    const key = JSON.stringify([edge.from, edge.to]);
+    if (!ids.has(edge.from) || !ids.has(edge.to) || edge.from === edge.to || edges.has(key))
+      ctx.addIssue({ code: "custom", message: "Invalid or duplicate transition" });
+    edges.add(key);
+  }
+});
+function defaultDeliveryWorkflow() {
+  const stages = [
+    { id: "backlog", name: "Backlog", category: "backlog", behavior: "manual" },
+    { id: "todo", name: "Todo", category: "unstarted", behavior: "manual" },
+    { id: "progress", name: "In Progress", category: "started", behavior: "agent_start" },
+    { id: "review", name: "In Review", category: "started", behavior: "pr_opened" },
+    { id: "stage-ready", name: "Ready for Staging", category: "started", behavior: "merged" },
+    { id: "staging", name: "In Staging", category: "started", behavior: "staging" },
+    { id: "qa", name: "In QA", category: "started", behavior: "qa_started" },
+    { id: "prod-ready", name: "Ready for Prod", category: "started", behavior: "qa_passed" },
+    { id: "released", name: "Released", category: "completed", behavior: "released" },
+    { id: "canceled", name: "Canceled", category: "canceled", behavior: "manual" },
+    { id: "duplicate", name: "Duplicate", category: "canceled", behavior: "manual" }
+  ];
+  const transitions = stages.slice(1, 9).map((stage, i) => ({
+    from: stages[i].id,
+    to: stage.id,
+    // Recheck the entire delivery path when a revision or staging deployment changes mid-flight.
+    requires: stages.slice(0, i + 2).flatMap((s) => deliveryEvidenceKindSchema.safeParse(s.behavior).success ? [s.behavior] : [])
+  }));
+  for (const stage of stages) {
+    for (const target of ["todo", "canceled", "duplicate"]) {
+      if (target !== stage.id && !transitions.some((t) => t.from === stage.id && t.to === target))
+        transitions.push({ from: stage.id, to: target, requires: [] });
+    }
+  }
+  return { revision: 0, stages, transitions, attentionColumn: true };
+}
+var trackerSourceSchema = z2.strictObject({ workspace: id, id, identifier: id, url: z2.string().url() });
+var trackerPlanSchema = z2.strictObject({ id, name: z2.string().trim().min(1).max(200), description: text.default(""), source: trackerSourceSchema.optional() });
+var trackerCommentSchema = z2.strictObject({ id, body: text, author: id, createdAt: z2.number(), sourceId: id.optional() });
+var trackerEvidenceSchema = z2.strictObject({
+  id,
+  kind: deliveryEvidenceKindSchema,
+  revision: id,
+  reference: z2.string().min(1).max(2e3),
+  deploymentId: id.optional(),
+  runId: id.optional(),
+  createdAt: z2.number(),
+  author: id
+});
+var trackerIssueSchema = z2.strictObject({
+  id,
+  identifier: id,
+  title: z2.string().trim().min(1).max(500),
+  description: text,
+  stageId: id,
+  planId: id.nullable(),
+  parentId: id.nullable(),
+  assignee: id.nullable(),
+  priority: z2.number().int().min(0).max(4),
+  labels: z2.array(z2.string().max(100)).max(100),
+  blockedBy: z2.array(id).max(100),
+  externalBlockers: z2.array(z2.string().max(2e3)).max(100),
+  agentEligible: z2.boolean(),
+  automationHeld: z2.boolean(),
+  revision: id.nullable(),
+  attention: z2.strictObject({
+    id,
+    message: z2.string().trim().min(1).max(1e4),
+    runId: id.optional(),
+    origin: z2.enum(["manual", "run"]).default("manual")
+  }).nullable(),
+  threadId: id,
+  runIds: z2.array(id),
+  comments: z2.array(trackerCommentSchema),
+  evidence: z2.array(trackerEvidenceSchema),
+  history: z2.array(z2.strictObject({ at: z2.number(), actor: id, action: z2.string(), from: id.optional(), to: id.optional() })),
+  source: trackerSourceSchema.optional(),
+  sourceAssignee: z2.string().optional(),
+  createdAt: z2.number(),
+  updatedAt: z2.number(),
+  version: z2.number().int().nonnegative()
+});
+var trackerSnapshotSchema = z2.strictObject({
+  workflow: deliveryWorkflowSchema,
+  issues: z2.array(trackerIssueSchema),
+  plans: z2.array(trackerPlanSchema),
+  members: z2.array(id)
+});
+var issueFields = {
+  title: z2.string().trim().min(1).max(500),
+  description: text.default(""),
+  planId: id.nullable().default(null),
+  parentId: id.nullable().default(null),
+  assignee: id.nullable().default(null),
+  priority: z2.number().int().min(0).max(4).default(0),
+  labels: z2.array(z2.string().max(100)).max(100).default([]),
+  blockedBy: z2.array(id).max(100).default([]),
+  externalBlockers: z2.array(z2.string().max(2e3)).max(100).default([]),
+  agentEligible: z2.boolean().default(false),
+  revision: id.nullable().default(null)
+};
+var trackerImportSchema = z2.strictObject({
+  workspace: id,
+  teamId: id,
+  stages: z2.array(deliveryStageSchema).min(1).max(100),
+  stageMapping: z2.record(z2.string(), id),
+  adoptWorkflow: z2.boolean(),
+  plans: z2.array(z2.strictObject({ source: trackerSourceSchema, name: z2.string().min(1).max(200), description: text })).max(500),
+  issues: z2.array(z2.strictObject({
+    source: trackerSourceSchema,
+    title: issueFields.title,
+    description: text,
+    stageId: id,
+    planId: id.nullable(),
+    parentId: id.nullable(),
+    assignee: id.nullable(),
+    sourceAssignee: z2.string().optional(),
+    priority: issueFields.priority,
+    labels: issueFields.labels,
+    blockedBy: z2.array(id).max(100),
+    externalBlockers: z2.array(z2.string().max(2e3)).max(100).default([]),
+    comments: z2.array(trackerCommentSchema).max(1e3),
+    createdAt: z2.number()
+  })).max(2e3),
+  omissions: z2.array(z2.string().max(2e3)).max(500).default([])
+});
+var trackerOperationSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("tracker.sync") }),
+  z2.strictObject({ kind: z2.literal("issue.create"), id: id.max(147), stageId: id.optional(), ...issueFields }),
+  z2.strictObject({ kind: z2.literal("issue.update"), id, version: z2.number().int(), changes: trackerIssueSchema.pick({
+    title: true,
+    description: true,
+    planId: true,
+    parentId: true,
+    assignee: true,
+    priority: true,
+    labels: true,
+    blockedBy: true,
+    externalBlockers: true,
+    agentEligible: true,
+    revision: true
+  }).partial() }),
+  z2.strictObject({ kind: z2.literal("plan.save"), ...trackerPlanSchema.shape }),
+  z2.strictObject({ kind: z2.literal("workflow.save"), workflow: deliveryWorkflowSchema, replacements: z2.record(z2.string(), id).default({}) }),
+  z2.strictObject({ kind: z2.literal("issue.transition"), id, version: z2.number().int(), stageId: id }),
+  z2.strictObject({ kind: z2.literal("issue.attention"), id, version: z2.number().int(), message: z2.string().trim().min(1).max(1e4), runId: id.optional() }),
+  z2.strictObject({ kind: z2.literal("issue.resolve"), id, version: z2.number().int(), attentionId: id }),
+  z2.strictObject({ kind: z2.literal("issue.resume"), id, version: z2.number().int() }),
+  z2.strictObject({ kind: z2.literal("issue.revision"), id, version: z2.number().int(), revision: id, runId: id }),
+  z2.strictObject({ kind: z2.literal("issue.comment"), id, commentId: id, body: text }),
+  z2.strictObject({ kind: z2.literal("issue.evidence"), id, evidenceId: id, evidence: trackerEvidenceSchema.omit({ id: true, author: true, createdAt: true }) }),
+  z2.strictObject({ kind: z2.literal("import.preview"), input: trackerImportSchema }),
+  z2.strictObject({ kind: z2.literal("import.commit"), previewId: id })
+]);
+var trackerImportPreviewSchema = z2.strictObject({
+  previewId: id,
+  creates: z2.number().int(),
+  skips: z2.number().int(),
+  plans: z2.number().int(),
+  omissions: z2.array(z2.string())
+});
+
 // src/v2.ts
 var protocolVersion = { major: 2, minor: 3 };
 var conversationContinuationCapability = "conversation_continuation";
@@ -117,31 +303,32 @@ var abandonedConversationContinuationCapability = "abandoned_conversation_contin
 var repositoryAccessCapability = "repository_checkout_v1";
 var workflowInstallCapability = "workflow_install_v1";
 var runDelegationCapability = "run_delegation_v1";
+var orchestratorGuidanceCapability = "orchestrator_guidance_v1";
 var runUsageCapability = "run_usage_v1";
 var delegationTokenPrefix = "drisp_dlg_";
-var runArtifactNameSchema = z2.string().regex(/^[a-z][a-z0-9_]{0,63}$/);
+var runArtifactNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,63}$/);
 var runArtifactMaxBytes = 64 * 1024;
-var secretEnvironmentSchema = z2.record(
-  z2.string().regex(/^(?:OPENAI_API_KEY|ANTHROPIC_API_KEY|CLAUDE_CODE_OAUTH_TOKEN|NPM_TOKEN|NODE_AUTH_TOKEN|PIP_INDEX_URL|PIP_EXTRA_INDEX_URL|UV_INDEX_URL|DRISP_TEST_[A-Z0-9_]+)$/),
-  z2.string().regex(/^projects\/[a-zA-Z0-9-]+\/secrets\/[a-zA-Z0-9_-]+\/versions\/(?:latest|[0-9]+)$/)
+var secretEnvironmentSchema = z3.record(
+  z3.string().regex(/^(?:OPENAI_API_KEY|ANTHROPIC_API_KEY|CLAUDE_CODE_OAUTH_TOKEN|NPM_TOKEN|NODE_AUTH_TOKEN|PIP_INDEX_URL|PIP_EXTRA_INDEX_URL|UV_INDEX_URL|DRISP_TEST_[A-Z0-9_]+)$/),
+  z3.string().regex(/^projects\/[a-zA-Z0-9-]+\/secrets\/[a-zA-Z0-9_-]+\/versions\/(?:latest|[0-9]+)$/)
 );
-var permissionAnswerSchema = z2.strictObject({
-  kind: z2.literal("permission"),
-  decision: z2.enum(["allow", "deny"]),
-  reason: z2.string().max(4096).optional()
+var permissionAnswerSchema = z3.strictObject({
+  kind: z3.literal("permission"),
+  decision: z3.enum(["allow", "deny"]),
+  reason: z3.string().max(4096).optional()
 });
-var id = z2.string().min(1).max(160);
-var sequence = z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var id2 = z3.string().min(1).max(160);
+var sequence = z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 var positive = sequence.refine((n) => n > 0);
-var timestamp = z2.iso.datetime();
-var scopeSchema = z2.discriminatedUnion("visibility", [
-  z2.strictObject({ visibility: z2.literal("organization") }),
-  z2.strictObject({ visibility: z2.literal("private"), ownerUserId: id })
+var timestamp = z3.iso.datetime();
+var scopeSchema = z3.discriminatedUnion("visibility", [
+  z3.strictObject({ visibility: z3.literal("organization") }),
+  z3.strictObject({ visibility: z3.literal("private"), ownerUserId: id2 })
 ]);
-var installedWorkflowsSchema = z2.array(InstalledWorkflowSchema).max(256);
-var harnessSchema = z2.enum(["claude-code", "codex"]);
-var harnessReadinessSchema = z2.strictObject({ installed: z2.boolean(), signedIn: z2.boolean() });
-var runnerReadinessSchema = z2.strictObject({
+var installedWorkflowsSchema = z3.array(InstalledWorkflowSchema).max(256);
+var harnessSchema = z3.enum(["claude-code", "codex"]);
+var harnessReadinessSchema = z3.strictObject({ installed: z3.boolean(), signedIn: z3.boolean() });
+var runnerReadinessSchema = z3.strictObject({
   "claude-code": harnessReadinessSchema.optional(),
   codex: harnessReadinessSchema.optional()
 });
@@ -156,25 +343,27 @@ function readinessFixCommand(harness, readiness) {
   return void 0;
 }
 var runnerUpdateCommand = "npm i -g @drisp/cli";
-var interruptionSchema = z2.strictObject({
-  interruptionId: id,
+var interruptionSchema = z3.strictObject({
+  interruptionId: id2,
   revision: positive,
   /** `waiting` (root ADR-0008) is non-human: a Run parked until one of its children closes or parks. */
-  kind: z2.enum(["permission", "question", "guidance", "recovery", "waiting"]),
-  message: z2.string().max(16384),
-  requestId: id.optional()
+  kind: z3.enum(["permission", "question", "guidance", "recovery", "waiting"]),
+  message: z3.string().max(16384),
+  /** Explicit technical question for a parent; absent always reserves the answer to a member. */
+  respondent: z3.enum(["orchestrator"]).optional(),
+  requestId: id2.optional()
 });
-var workflowIdentitySchema = z2.strictObject({
-  name: z2.string().min(1).max(128),
-  version: z2.string().min(1).max(128).optional()
+var workflowIdentitySchema = z3.strictObject({
+  name: z3.string().min(1).max(128),
+  version: z3.string().min(1).max(128).optional()
 });
-var buildCloseReasonSchema = z2.enum([
+var buildCloseReasonSchema = z3.enum([
   "workflow_template_mismatch",
   "child_project_dir_invalid",
   "build_not_approved",
   "approval_question_missing"
 ]);
-var runCloseReasonSchema = z2.enum([
+var runCloseReasonSchema = z3.enum([
   "execution_terminal",
   "cancelled_before_start",
   "admission_failed",
@@ -192,53 +381,53 @@ var runCloseReasonSchema = z2.enum([
   ...buildCloseReasonSchema.options
 ]);
 var factIdentity = {
-  runId: id,
-  attemptId: id,
+  runId: id2,
+  attemptId: id2,
   executionRevision: positive,
   emittedAt: timestamp
 };
-var runUsageSchema = z2.strictObject({ counted: sequence, cacheRead: sequence });
+var runUsageSchema = z3.strictObject({ counted: sequence, cacheRead: sequence });
 var reportedUsage = { usage: runUsageSchema.optional() };
-var controlRecordSchema = z2.discriminatedUnion("kind", [
+var controlRecordSchema = z3.discriminatedUnion("kind", [
   /** Instance-scoped, not tied to a Run: the full replacement inventory of installed Workflows. */
-  z2.strictObject({ kind: z2.literal("workflows.changed"), workflows: installedWorkflowsSchema }),
+  z3.strictObject({ kind: z3.literal("workflows.changed"), workflows: installedWorkflowsSchema }),
   /** Instance-scoped, not tied to a Run: the Runner's full Readiness, sent when it changes after hello. */
-  z2.strictObject({ kind: z2.literal("readiness.changed"), readiness: runnerReadinessSchema }),
-  z2.strictObject({ kind: z2.literal("assignment.accepted"), runId: id, attemptId: id }),
-  z2.strictObject({
-    kind: z2.literal("assignment.rejected"),
-    runId: id,
-    attemptId: id,
-    reason: z2.string().max(1024)
+  z3.strictObject({ kind: z3.literal("readiness.changed"), readiness: runnerReadinessSchema }),
+  z3.strictObject({ kind: z3.literal("assignment.accepted"), runId: id2, attemptId: id2 }),
+  z3.strictObject({
+    kind: z3.literal("assignment.rejected"),
+    runId: id2,
+    attemptId: id2,
+    reason: z3.string().max(1024)
   }),
-  z2.strictObject({
-    kind: z2.literal("run.started"),
+  z3.strictObject({
+    kind: z3.literal("run.started"),
     ...factIdentity,
     /** Absent from runners that predate Workflow reporting. */
     workflow: workflowIdentitySchema.optional()
   }),
-  z2.strictObject({ kind: z2.literal("run.resumed"), ...factIdentity }),
-  z2.strictObject({
-    kind: z2.literal("run.attention"),
+  z3.strictObject({ kind: z3.literal("run.resumed"), ...factIdentity }),
+  z3.strictObject({
+    kind: z3.literal("run.attention"),
     ...factIdentity,
     interruption: interruptionSchema,
-    occupancy: z2.enum(["held", "released"]),
+    occupancy: z3.enum(["held", "released"]),
     historyThrough: sequence,
-    continuation: z2.discriminatedUnion("kind", [
-      z2.strictObject({ kind: z2.literal("live_request") }),
-      z2.strictObject({ kind: z2.literal("local_checkpoint"), checkpointId: id }),
-      z2.strictObject({ kind: z2.literal("portable_checkpoint"), checkpointId: id }),
-      z2.strictObject({ kind: z2.literal("repair_required"), detail: z2.string().max(4096) })
+    continuation: z3.discriminatedUnion("kind", [
+      z3.strictObject({ kind: z3.literal("live_request") }),
+      z3.strictObject({ kind: z3.literal("local_checkpoint"), checkpointId: id2 }),
+      z3.strictObject({ kind: z3.literal("portable_checkpoint"), checkpointId: id2 }),
+      z3.strictObject({ kind: z3.literal("repair_required"), detail: z3.string().max(4096) })
     ]),
     ...reportedUsage
   }),
-  z2.strictObject({
-    kind: z2.literal("run.finished"),
+  z3.strictObject({
+    kind: z3.literal("run.finished"),
     ...factIdentity,
-    status: z2.enum(["completed", "failed", "cancelled"]),
+    status: z3.enum(["completed", "failed", "cancelled"]),
     historyThrough: sequence,
     /** No setup/harness executed and no workspace was produced; safe to retire without export. */
-    workspaceUnavailable: z2.literal(true).optional(),
+    workspaceUnavailable: z3.literal(true).optional(),
     /**
      * Why a Build Run failed, as its close reason (docs/specs/build-orchestrator.md). Sent only for a grant with
      * `parent` or `delegationToken`, which only a Hub that knows this field issues.
@@ -250,92 +439,93 @@ var controlRecordSchema = z2.discriminatedUnion("kind", [
    * The usage of a Run while it executes, for a grant marked `reportUsage`. Not an execution fact: it carries no
    * execution revision, so it never advances, parks or closes the Run, and never wakes its parent.
    */
-  z2.strictObject({ kind: z2.literal("run.usage"), runId: id, attemptId: id, ...runUsageSchema.shape }),
-  z2.strictObject({ kind: z2.literal("command.applied"), runId: id, attemptId: id, commandId: id }),
-  z2.strictObject({
-    kind: z2.literal("command.rejected"),
-    runId: id,
-    attemptId: id,
-    commandId: id,
-    reason: z2.string().max(1024)
+  z3.strictObject({ kind: z3.literal("run.usage"), runId: id2, attemptId: id2, ...runUsageSchema.shape }),
+  z3.strictObject({ kind: z3.literal("command.applied"), runId: id2, attemptId: id2, commandId: id2 }),
+  z3.strictObject({
+    kind: z3.literal("command.rejected"),
+    runId: id2,
+    attemptId: id2,
+    commandId: id2,
+    reason: z3.string().max(1024)
   }),
-  z2.strictObject({ kind: z2.literal("revoked_not_started"), runId: id, attemptId: id })
+  z3.strictObject({ kind: z3.literal("revoked_not_started"), runId: id2, attemptId: id2 })
 ]);
-var repositoryRefSchema = z2.string().min(1).max(512).regex(
+var repositoryRefSchema = z3.string().min(1).max(512).regex(
   /^(?![-/])(?!.*\.\.)(?!.*@\{)(?!.*(?:^|\/)\.)(?!.*\.lock(?:\/|$))(?!.*\/\/)[^\x00-\x20\x7f~^:?*\[\\]+(?<![/.])$/
 );
-var repositoryWorkingDirectorySchema = z2.string().min(1).max(1024).regex(
+var repositoryWorkingDirectorySchema = z3.string().min(1).max(1024).regex(
   /^(?:\.|(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?!.*(?:^|\/)\.git(?:\/|$))[^\x00-\x1f\x7f\\:]+(?<!\/))$/
 );
 var repositoryIdentity = {
-  repositoryId: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  installationId: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  owner: z2.string().min(1).max(100).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/),
-  name: z2.string().min(1).max(100).regex(/^(?!\.{1,2}$)[a-zA-Z0-9_.-]+$/)
+  repositoryId: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  installationId: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  owner: z3.string().min(1).max(100).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/),
+  name: z3.string().min(1).max(100).regex(/^(?!\.{1,2}$)[a-zA-Z0-9_.-]+$/)
 };
-var repositoryBindingSchema = z2.strictObject({
-  id,
-  label: z2.string().min(1).max(160),
+var repositoryBindingSchema = z3.strictObject({
+  id: id2,
+  label: z3.string().min(1).max(160),
   ...repositoryIdentity,
   defaultRef: repositoryRefSchema,
   workingDirectory: repositoryWorkingDirectorySchema,
-  setupCommands: z2.array(z2.string().min(1).max(8192)).max(16),
+  setupCommands: z3.array(z3.string().min(1).max(8192)).max(16),
   revision: positive,
-  enabled: z2.boolean()
+  enabled: z3.boolean()
 });
-var repositorySourceSchema = z2.strictObject({
-  bindingId: id,
+var repositorySourceSchema = z3.strictObject({
+  bindingId: id2,
   ...repositoryIdentity,
   ref: repositoryRefSchema,
-  commitSha: z2.string().regex(/^[0-9a-f]{40}$/),
+  commitSha: z3.string().regex(/^[0-9a-f]{40}$/),
   branch: repositoryRefSchema,
   workingDirectory: repositoryWorkingDirectorySchema,
-  setupCommands: z2.array(z2.string().min(1).max(8192)).max(16),
+  setupCommands: z3.array(z3.string().min(1).max(8192)).max(16),
   configRevision: positive
 });
-var workflowSourceSchema = z2.string().max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*$/);
-var workflowReferenceSchema = z2.union([
-  z2.string().max(512),
-  z2.strictObject({
-    name: z2.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/),
+var workflowSourceSchema = z3.string().max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*$/);
+var workflowReferenceSchema = z3.union([
+  z3.string().max(512),
+  z3.strictObject({
+    name: z3.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/),
     source: workflowSourceSchema.optional(),
-    ref: z2.string().min(1).max(512).optional(),
-    version: z2.string().min(1).max(128).regex(/^\d[A-Za-z0-9_.+-]*$/).optional()
+    ref: z3.string().min(1).max(512).optional(),
+    version: z3.string().min(1).max(128).regex(/^\d[A-Za-z0-9_.+-]*$/).optional()
   })
 ]);
 var workflowName = (workflow) => typeof workflow === "object" ? workflow.name : workflow;
 var installReference = (workflow) => typeof workflow === "object" && workflow.source !== void 0 ? workflow : void 0;
 var sameWorkflow = (a, b) => canonicalJson(a ?? null) === canonicalJson(b ?? null);
-var runSpecSchema = z2.strictObject({
-  prompt: z2.string().min(1).max(131072),
-  projectDir: z2.string().min(1).max(4096),
+var runSpecSchema = z3.strictObject({
+  prompt: z3.string().min(1).max(131072),
+  projectDir: z3.string().min(1).max(4096),
   harness: harnessSchema,
   workflow: workflowReferenceSchema.optional(),
   repository: repositorySourceSchema.optional()
 });
-var runKeySchema = z2.string().min(1).max(160);
-var delegationSchema = z2.strictObject({
-  maxChildren: z2.number().int().min(1).max(8),
-  tokenBudget: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER)
-});
-var tokenCapSchema = z2.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var runParentIntentSchema = z2.strictObject({ runId: id, tokenCap: tokenCapSchema.optional() });
-var runParentSchema = z2.strictObject({ runId: id, tokenCap: tokenCapSchema });
-var commandSchema = z2.strictObject({
-  commandId: id,
-  hubEpoch: id,
-  runId: id,
+var runKeySchema = z3.string().min(1).max(160);
+var delegationSchema = z3.strictObject({
+  // Omitted: follow the Runner capacity. An explicit value is a per-Build ceiling.
+  maxChildren: z3.number().int().min(1).max(64).optional(),
+  tokenBudget: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER)
+});
+var tokenCapSchema = z3.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var runParentIntentSchema = z3.strictObject({ runId: id2, tokenCap: tokenCapSchema.optional() });
+var runParentSchema = z3.strictObject({ runId: id2, tokenCap: tokenCapSchema });
+var commandSchema = z3.strictObject({
+  commandId: id2,
+  hubEpoch: id2,
+  runId: id2,
   expectedRecordRevision: sequence.optional(),
-  intent: z2.discriminatedUnion("kind", [
-    z2.strictObject({
-      kind: z2.literal("start"),
-      sessionId: id,
+  intent: z3.discriminatedUnion("kind", [
+    z3.strictObject({
+      kind: z3.literal("start"),
+      sessionId: id2,
       /**
        * Absent: the Hub resolves the Runner member-first (root ADR-0005): the Session's conversation Runner, else
        * the starting member's own ready Personal Runner, else the Team default, else the start is refused.
        */
-      runnerId: id.optional(),
-      computeProfileId: id.optional(),
+      runnerId: id2.optional(),
+      computeProfileId: id2.optional(),
       scope: scopeSchema,
       spec: runSpecSchema,
       key: runKeySchema.optional(),
@@ -344,160 +534,167 @@ var commandSchema = z2.strictObject({
       /** Delegated starts only, and required on them. */
       parent: runParentIntentSchema.optional()
     }),
-    z2.strictObject({ kind: z2.literal("cancel") }),
-    z2.strictObject({ kind: z2.literal("abandon") }),
-    z2.strictObject({ kind: z2.literal("steer"), text: z2.string().min(1).max(131072) }),
-    z2.strictObject({
-      kind: z2.literal("answer"),
-      interruptionId: id,
+    z3.strictObject({ kind: z3.literal("cancel") }),
+    z3.strictObject({ kind: z3.literal("abandon") }),
+    z3.strictObject({ kind: z3.literal("steer"), text: z3.string().min(1).max(131072) }),
+    z3.strictObject({
+      kind: z3.literal("answer"),
+      interruptionId: id2,
       expectedInterruptionRevision: positive,
-      requestId: id.optional(),
-      answer: z2.json()
+      requestId: id2.optional(),
+      answer: z3.json()
     }),
-    z2.strictObject({
-      kind: z2.literal("resume"),
-      interruptionId: id,
-      guidance: z2.string().max(131072).optional()
+    z3.strictObject({
+      kind: z3.literal("resume"),
+      interruptionId: id2,
+      guidance: z3.string().max(131072).optional()
     }),
     /**
      * A member rewrites an Orchestrator's `delegation.tokenBudget` (root ADR-0011), never below what its children
      * used. With `resume`, a parked Orchestrator with no live child is resumed when the value is strictly greater.
      * Hub-only: never delivered to a Runner.
      */
-    z2.strictObject({
-      kind: z2.literal("setBudget"),
+    z3.strictObject({
+      kind: z3.literal("setBudget"),
       tokenBudget: delegationSchema.shape.tokenBudget,
-      resume: z2.boolean().optional()
+      resume: z3.boolean().optional()
     })
   ])
 });
-var grantSchema = z2.strictObject({
-  commandId: id,
-  hubEpoch: id,
-  runId: id,
-  sessionId: id,
-  runnerId: id,
-  installationId: id,
-  attemptId: id,
+var deliveredCommandSchema = commandSchema.extend({ orchestratorRunId: id2.optional() });
+var grantSchema = z3.strictObject({
+  commandId: id2,
+  hubEpoch: id2,
+  runId: id2,
+  sessionId: id2,
+  runnerId: id2,
+  installationId: id2,
+  attemptId: id2,
   generation: positive,
   baseExecutionRevision: sequence,
   baseHistorySeq: sequence,
   cloudHistoryThrough: sequence,
-  purpose: z2.enum(["start", "resume"]),
+  purpose: z3.enum(["start", "resume"]),
   spec: runSpecSchema,
-  continuation: z2.json().optional(),
+  continuation: z3.json().optional(),
+  /** Authenticated source of a delegated continuation; absence retains member semantics. */
+  orchestratorRunId: id2.optional(),
   /** A new Run in a durable conversation; never resumes the predecessor's lifecycle. */
-  previousRun: z2.strictObject({
-    runId: id,
+  previousRun: z3.strictObject({
+    runId: id2,
     executionRevision: sequence,
     historyProduced: sequence,
     /** Hub-confirmed administrative closure; allows an exact parked predecessor snapshot. */
-    closeReason: z2.literal("abandoned").optional(),
-    checkpoint: z2.strictObject({ checkpointId: id, checksum: z2.string().regex(/^[a-f0-9]{64}$/) }).optional()
+    closeReason: z3.literal("abandoned").optional(),
+    checkpoint: z3.strictObject({ checkpointId: id2, checksum: z3.string().regex(/^[a-f0-9]{64}$/) }).optional()
   }).optional(),
-  checkpoint: z2.strictObject({ checkpointId: id, checksum: z2.string().regex(/^[a-f0-9]{64}$/) }).optional(),
+  checkpoint: z3.strictObject({ checkpointId: id2, checksum: z3.string().regex(/^[a-f0-9]{64}$/) }).optional(),
   /** This attempt's delegation token: only for a Run started with `delegation`, only to a `run_delegation_v1` Runner. */
-  delegationToken: z2.string().min(32).max(256).optional(),
+  delegationToken: z3.string().min(32).max(256).optional(),
   /** Copied from the start intent of a delegated child. */
   parent: runParentSchema.optional(),
   /** The runner reports this attempt's usage: set only for a `run_usage_v1` Runner. */
-  reportUsage: z2.literal(true).optional()
+  reportUsage: z3.literal(true).optional()
 });
-var historyRecordSchema = z2.strictObject({
-  eventId: id,
-  attemptId: id,
+var historyRecordSchema = z3.strictObject({
+  eventId: id2,
+  attemptId: id2,
   emittedAt: timestamp,
-  kind: z2.string().min(1).max(128),
-  data: z2.json()
-});
-var runnerFrameSchema = z2.discriminatedUnion("type", [
-  z2.strictObject({
-    type: z2.literal("hello"),
-    role: z2.literal("runner"),
-    protocol: z2.strictObject({ major: z2.literal(2), minor: sequence }),
-    runnerId: id,
-    installationId: id,
-    softwareVersion: z2.string().max(128),
-    capabilities: z2.array(z2.string().max(128)).max(64),
+  kind: z3.string().min(1).max(128),
+  data: z3.json()
+});
+var runnerFrameSchema = z3.discriminatedUnion("type", [
+  z3.strictObject({
+    type: z3.literal("hello"),
+    role: z3.literal("runner"),
+    protocol: z3.strictObject({ major: z3.literal(2), minor: sequence }),
+    runnerId: id2,
+    installationId: id2,
+    softwareVersion: z3.string().max(128),
+    capabilities: z3.array(z3.string().max(128)).max(64),
     /** Absent from older runners: the Hub treats the inventory as unknown, never as empty. */
     workflows: installedWorkflowsSchema.optional(),
     /** Absent from older runners, and from a runner that has not finished its first check: unknown, not "not ready". */
     readiness: runnerReadinessSchema.optional(),
-    control: z2.strictObject({ firstRetainedSeq: positive, lastProducedSeq: sequence })
+    control: z3.strictObject({ firstRetainedSeq: positive, lastProducedSeq: sequence })
   }),
-  z2.strictObject({
-    type: z2.literal("control.batch"),
+  z3.strictObject({
+    type: z3.literal("control.batch"),
     firstSeq: positive,
-    records: z2.array(controlRecordSchema).min(1).max(128)
+    records: z3.array(controlRecordSchema).min(1).max(128)
   }),
-  z2.strictObject({
-    type: z2.literal("history.batch"),
-    runId: id,
+  z3.strictObject({
+    type: z3.literal("history.batch"),
+    runId: id2,
     firstSeq: positive,
-    records: z2.array(historyRecordSchema).min(1).max(128)
+    records: z3.array(historyRecordSchema).min(1).max(128)
   }),
-  z2.strictObject({ type: z2.literal("ping"), nonce: id }),
-  z2.strictObject({
-    type: z2.literal("reconcile.page"),
-    inventoryId: id.default("single-page"),
+  z3.strictObject({ type: z3.literal("ping"), nonce: id2 }),
+  z3.strictObject({
+    type: z3.literal("reconcile.page"),
+    inventoryId: id2.default("single-page"),
     page: sequence.default(0),
-    complete: z2.boolean(),
-    runs: z2.array(
-      z2.strictObject({
-        runId: id,
-        attemptId: id,
+    complete: z3.boolean(),
+    runs: z3.array(
+      z3.strictObject({
+        runId: id2,
+        attemptId: id2,
         executionRevision: sequence,
-        phase: z2.enum(["admitted", "prepared", "executing", "parked", "terminal", "recovery"])
+        phase: z3.enum(["admitted", "prepared", "executing", "parked", "terminal", "recovery"])
       })
     ).max(128)
   })
 ]);
-var runViewSchema = z2.object({
-  runId: id,
-  sessionId: id,
-  runnerId: id,
-  computeProfileId: id.optional(),
+var runViewSchema = z3.object({
+  runId: id2,
+  sessionId: id2,
+  runnerId: id2,
+  computeProfileId: id2.optional(),
   scope: scopeSchema,
   recordRevision: positive,
-  label: z2.string().max(160).optional(),
+  label: z3.string().max(160).optional(),
   key: runKeySchema.optional(),
   parent: runParentSchema.optional(),
   /**
    * Not strict, unlike the start intent's: a Hub keeps more on the Run's delegation (`initialTokenBudget`) than it
    * shows, and a client never refuses a view for a field it does not read.
    */
-  delegation: z2.object(delegationSchema.shape).optional(),
+  delegation: z3.object({
+    ...delegationSchema.shape,
+    // A resolved Runner default may exceed the explicit settings ceiling on configured Runners.
+    maxChildren: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
+  }).optional(),
   /** The largest cumulative usage the Run's Runner reported; absent until one does (an older Runner never does). */
   usage: runUsageSchema.optional(),
   /** Resolved by the runner at start; absent until the Run starts and for runners that predate reporting. */
   workflow: workflowIdentitySchema.optional(),
-  execution: z2.object({
-    status: z2.enum(["running", "awaiting_attention", "completed", "failed", "cancelled"]),
+  execution: z3.object({
+    status: z3.enum(["running", "awaiting_attention", "completed", "failed", "cancelled"]),
     revision: positive,
-    attemptId: id,
-    occupancy: z2.enum(["held", "released"]),
+    attemptId: id2,
+    occupancy: z3.enum(["held", "released"]),
     startedAt: timestamp.optional(),
     endedAt: timestamp.optional(),
     interruption: interruptionSchema.optional()
   }).nullable(),
-  scheduling: z2.enum(["queued", "dispatching", "admitted", "idle"]),
-  closed: z2.boolean(),
-  closeReason: z2.string().optional(),
-  cancellation: id.optional(),
+  scheduling: z3.enum(["queued", "dispatching", "admitted", "idle"]),
+  closed: z3.boolean(),
+  closeReason: z3.string().optional(),
+  cancellation: id2.optional(),
   pendingResume: commandSchema.shape.intent.optional(),
   /** Derived per viewer; absent on older Hubs. Never grants execution authority. */
-  runnerStopped: z2.boolean().optional(),
-  canAbandon: z2.boolean().optional(),
+  runnerStopped: z3.boolean().optional(),
+  canAbandon: z3.boolean().optional(),
   historyThrough: sequence,
   expectedHistoryThrough: sequence.optional(),
   createdAt: sequence,
-  checkpoint: z2.object({ id, state: z2.enum(["pending", "ready"]), checksum: z2.string().optional() }).optional()
+  checkpoint: z3.object({ id: id2, state: z3.enum(["pending", "ready"]), checksum: z3.string().optional() }).optional()
 });
-var clientFrameSchema = z2.discriminatedUnion("type", [
-  z2.strictObject({ type: z2.literal("watch"), hubEpoch: id, runIds: z2.array(id).max(100) }),
-  z2.strictObject({ type: z2.literal("watch.ack"), subscriptionId: id, through: sequence }),
-  z2.strictObject({ type: z2.literal("command.submit"), command: commandSchema }),
-  z2.strictObject({ type: z2.literal("ping"), nonce: id })
+var clientFrameSchema = z3.discriminatedUnion("type", [
+  z3.strictObject({ type: z3.literal("watch"), hubEpoch: id2, runIds: z3.array(id2).max(100) }),
+  z3.strictObject({ type: z3.literal("watch.ack"), subscriptionId: id2, through: sequence }),
+  z3.strictObject({ type: z3.literal("command.submit"), command: commandSchema }),
+  z3.strictObject({ type: z3.literal("ping"), nonce: id2 })
 ]);
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") {
@@ -508,76 +705,76 @@ function canonicalJson(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
 }
-var checkpointPathSchema = z2.string().min(1).max(4096).refine(
+var checkpointPathSchema = z3.string().min(1).max(4096).refine(
   (path) => !path.startsWith("/") && !path.includes("\\") && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".git")
 );
-var checkpointSchema = z2.strictObject({
-  version: z2.literal(1),
-  checkpointId: z2.string().min(1),
-  orgId: z2.string().min(1),
-  phase: z2.enum(["parked", "terminal"]),
-  runId: z2.string().min(1),
-  sessionId: z2.string().min(1),
-  sourceAttemptId: z2.string().min(1),
-  executionRevision: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  historyProduced: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  historyAck: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+var checkpointSchema = z3.strictObject({
+  version: z3.literal(1),
+  checkpointId: z3.string().min(1),
+  orgId: z3.string().min(1),
+  phase: z3.enum(["parked", "terminal"]),
+  runId: z3.string().min(1),
+  sessionId: z3.string().min(1),
+  sourceAttemptId: z3.string().min(1),
+  executionRevision: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  historyProduced: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  historyAck: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   grant: grantSchema,
-  gitHead: z2.string().regex(/^[0-9a-f]{40,64}$/),
-  gitBase: z2.string().regex(/^[0-9a-f]{40,64}$/).optional(),
-  gitBundle: z2.string(),
-  indexPatch: z2.string(),
-  files: z2.array(
-    z2.strictObject({ path: checkpointPathSchema, content: z2.string(), executable: z2.boolean() })
+  gitHead: z3.string().regex(/^[0-9a-f]{40,64}$/),
+  gitBase: z3.string().regex(/^[0-9a-f]{40,64}$/).optional(),
+  gitBundle: z3.string(),
+  indexPatch: z3.string(),
+  files: z3.array(
+    z3.strictObject({ path: checkpointPathSchema, content: z3.string(), executable: z3.boolean() })
   ).max(1e5),
-  deleted: z2.array(checkpointPathSchema).max(1e5),
-  sessionRows: z2.array(z2.strictObject({ kind: z2.string(), id: z2.string(), payload: z2.string() })),
-  history: z2.array(
-    z2.strictObject({ seq: z2.number().int().positive(), record: historyRecordSchema })
+  deleted: z3.array(checkpointPathSchema).max(1e5),
+  sessionRows: z3.array(z3.strictObject({ kind: z3.string(), id: z3.string(), payload: z3.string() })),
+  history: z3.array(
+    z3.strictObject({ seq: z3.number().int().positive(), record: historyRecordSchema })
   )
 });
 var connectCodeAlphabet = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
-var connectCodeSchema = z2.string().regex(/^[A-HJKMNP-Z2-9]{8}$/);
-var connectCodeRequestSchema = z2.strictObject({ hubEpoch: z2.string() });
-var connectCodeResponseSchema = z2.strictObject({
+var connectCodeSchema = z3.string().regex(/^[A-HJKMNP-Z2-9]{8}$/);
+var connectCodeRequestSchema = z3.strictObject({ hubEpoch: z3.string() });
+var connectCodeResponseSchema = z3.strictObject({
   code: connectCodeSchema,
   expiresAt: sequence
 });
-var connectRedeemRequestSchema = z2.strictObject({
-  code: z2.string().min(8).max(16),
-  installationId: id,
-  hostname: z2.string().min(1).max(255),
-  os: z2.string().min(1).max(64),
-  softwareVersion: z2.string().min(1).max(128)
-});
-var connectRedeemResponseSchema = z2.strictObject({
-  orgId: id,
-  hubEpoch: z2.string(),
-  runnerId: id,
-  installationId: id,
-  name: z2.string(),
-  token: z2.string().min(32),
-  credentialId: id,
+var connectRedeemRequestSchema = z3.strictObject({
+  code: z3.string().min(8).max(16),
+  installationId: id2,
+  hostname: z3.string().min(1).max(255),
+  os: z3.string().min(1).max(64),
+  softwareVersion: z3.string().min(1).max(128)
+});
+var connectRedeemResponseSchema = z3.strictObject({
+  orgId: id2,
+  hubEpoch: z3.string(),
+  runnerId: id2,
+  installationId: id2,
+  name: z3.string(),
+  token: z3.string().min(32),
+  credentialId: id2,
   expiresAt: sequence
 });
-var connectAlreadyConnectedSchema = z2.strictObject({
-  error: z2.literal("runner_already_connected"),
-  orgId: id,
-  runnerId: id,
-  name: z2.string()
+var connectAlreadyConnectedSchema = z3.strictObject({
+  error: z3.literal("runner_already_connected"),
+  orgId: id2,
+  runnerId: id2,
+  name: z3.string()
 });
-var audienceSchema = z2.enum(["personal", "team"]);
-var runnerListEntrySchema = z2.object({
-  id,
-  online: z2.number(),
-  capacity: z2.number(),
-  managed: z2.number(),
-  draining: z2.number(),
-  stopped: z2.number(),
-  name: z2.string().nullable(),
-  connectedBy: z2.string().nullable(),
+var audienceSchema = z3.enum(["personal", "team"]);
+var runnerListEntrySchema = z3.object({
+  id: id2,
+  online: z3.number(),
+  capacity: z3.number(),
+  managed: z3.number(),
+  draining: z3.number(),
+  stopped: z3.number(),
+  name: z3.string().nullable(),
+  connectedBy: z3.string().nullable(),
   audience: audienceSchema.nullable(),
-  softwareVersion: z2.string().nullable(),
+  softwareVersion: z3.string().nullable(),
   /** Milliseconds since the epoch of the last hello or disconnect; null before the first connection. */
   lastSeen: sequence.nullable(),
   /** Absent when the runner has not reported an inventory: unknown, not none. */
@@ -587,108 +784,108 @@ var runnerListEntrySchema = z2.object({
    * Runner seen by an admin (who may still Disconnect it), or a Runner a member did not connect. Absent from Hubs
    * older than Audience, like the list's `viewer`, `teamDefault` and `runsGoTo`.
    */
-  readOnly: z2.boolean().optional(),
+  readOnly: z3.boolean().optional(),
   /** What the Runner last reported; absent when it never has (an older runner, or one not yet connected). */
   readiness: runnerReadinessSchema.optional(),
   /**
    * True when the Runner reported a version below the Hub's minimum: it is listed as "Update required" and takes no
    * Runs until it is updated (`runnerUpdateCommand`). Absent from Hubs older than Readiness.
    */
-  updateRequired: z2.boolean().optional(),
+  updateRequired: z3.boolean().optional(),
   /**
    * True while it is paused as "Needs an owner": the member who connected this Team Runner left the Team, so it
    * takes no Runs until an admin adopts it (`/runners/{id}/adopt`) or Disconnects it. Absent from older Hubs.
    */
-  needsOwner: z2.boolean().optional()
+  needsOwner: z3.boolean().optional()
 });
-var teamDefaultSchema = z2.discriminatedUnion("kind", [
-  z2.strictObject({ kind: z2.literal("runner"), runnerId: id }),
-  z2.strictObject({ kind: z2.literal("profile"), profileId: id })
+var teamDefaultSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({ kind: z3.literal("runner"), runnerId: id2 }),
+  z3.strictObject({ kind: z3.literal("profile"), profileId: id2 })
 ]);
-var teamDefaultRequestSchema = z2.strictObject({
-  hubEpoch: z2.string(),
+var teamDefaultRequestSchema = z3.strictObject({
+  hubEpoch: z3.string(),
   teamDefault: teamDefaultSchema.nullable()
 });
-var runnerUpdateRequestSchema = z2.strictObject({
-  hubEpoch: z2.string(),
-  name: z2.string().max(100).optional(),
-  capacity: z2.number().int().min(1).max(64).optional(),
+var runnerUpdateRequestSchema = z3.strictObject({
+  hubEpoch: z3.string(),
+  name: z3.string().max(100).optional(),
+  capacity: z3.number().int().min(1).max(64).optional(),
   audience: audienceSchema.optional()
 }).refine(
   (update) => update.name !== void 0 || update.capacity !== void 0 || update.audience !== void 0,
   { message: "nothing to update" }
 );
-var runsGoToSchema = z2.union([
+var runsGoToSchema = z3.union([
   /** The viewer's own Runner: Personal, or one they connected that was widened to Team (DRI-42). */
-  z2.strictObject({ via: z2.literal("personal"), runnerId: id }),
-  z2.strictObject({ via: z2.literal("team_default"), runnerId: id }),
-  z2.strictObject({ via: z2.literal("team_default"), profileId: id }),
+  z3.strictObject({ via: z3.literal("personal"), runnerId: id2 }),
+  z3.strictObject({ via: z3.literal("team_default"), runnerId: id2 }),
+  z3.strictObject({ via: z3.literal("team_default"), profileId: id2 }),
   /** `runner_needs_owner`: the Team default is a Runner paused because the member who connected it left. */
-  z2.strictObject({ via: z2.literal("none"), reason: z2.enum(["no_runner_available", "runner_needs_owner"]) })
+  z3.strictObject({ via: z3.literal("none"), reason: z3.enum(["no_runner_available", "runner_needs_owner"]) })
 ]);
-var runnerListSchema = z2.object({
-  capabilities: z2.record(z2.string(), z2.boolean()).optional(),
-  historyRetentionDays: z2.number().int().positive().nullable().optional(),
+var runnerListSchema = z3.object({
+  capabilities: z3.record(z3.string(), z3.boolean()).optional(),
+  historyRetentionDays: z3.number().int().positive().nullable().optional(),
   /** Who the list was filtered for: a member sees their own and Team Runners, an admin every Runner. */
-  viewer: z2.object({ userId: z2.string(), admin: z2.boolean() }).optional(),
+  viewer: z3.object({ userId: z3.string(), admin: z3.boolean() }).optional(),
   teamDefault: teamDefaultSchema.nullable().optional(),
   runsGoTo: runsGoToSchema.optional(),
   /** The lowest Runner version this Hub sends Runs to. Absent from Hubs older than Readiness. */
-  minimumRunnerVersion: z2.string().optional(),
-  runners: z2.array(runnerListEntrySchema),
-  profiles: z2.array(z2.object({
-    id: z2.string(),
-    label: z2.string(),
-    projectDir: z2.string(),
-    repositoryRequired: z2.boolean().optional(),
+  minimumRunnerVersion: z3.string().optional(),
+  runners: z3.array(runnerListEntrySchema),
+  profiles: z3.array(z3.object({
+    id: z3.string(),
+    label: z3.string(),
+    projectDir: z3.string(),
+    repositoryRequired: z3.boolean().optional(),
     /** Marketplace refs baked into the profile's image; absent when the profile declares none. */
-    workflows: z2.array(z2.string()).optional(),
-    workflowSources: z2.array(z2.string()).optional()
+    workflows: z3.array(z3.string()).optional(),
+    workflowSources: z3.array(z3.string()).optional()
   }))
 });
-var runnerDisconnectRequestSchema = z2.strictObject({ hubEpoch: z2.string() });
+var runnerDisconnectRequestSchema = z3.strictObject({ hubEpoch: z3.string() });
 var hubEpochRequestSchema = runnerDisconnectRequestSchema;
-var runnerDisconnectPreviewSchema = z2.object({
-  runnerId: id,
-  name: z2.string().nullable(),
-  runs: z2.array(z2.object({
-    runId: id,
-    label: z2.string().optional(),
+var runnerDisconnectPreviewSchema = z3.object({
+  runnerId: id2,
+  name: z3.string().nullable(),
+  runs: z3.array(z3.object({
+    runId: id2,
+    label: z3.string().optional(),
     /** Working: executing now. Parked: waiting for a person, Runner released. Queued: not started yet. */
-    state: z2.enum(["working", "parked", "queued"])
+    state: z3.enum(["working", "parked", "queued"])
   })),
-  hiddenRuns: z2.number().int().nonnegative()
+  hiddenRuns: z3.number().int().nonnegative()
 });
-var runnerDisconnectResponseSchema = z2.object({
-  disconnected: z2.literal(true),
+var runnerDisconnectResponseSchema = z3.object({
+  disconnected: z3.literal(true),
   /** How many Runs were Stopped with the reason `runner_disconnected`. */
-  stoppedRuns: z2.number().int().nonnegative()
+  stoppedRuns: z3.number().int().nonnegative()
 });
 var runnerAdoptRequestSchema = hubEpochRequestSchema;
 var connectStartRequestSchema = connectRedeemRequestSchema.omit({ code: true });
-var connectStartResponseSchema = z2.strictObject({
+var connectStartResponseSchema = z3.strictObject({
   /** The machine's secret for polling; never shown. */
-  deviceCode: z2.string().min(32).max(160),
+  deviceCode: z3.string().min(32).max(160),
   code: connectCodeSchema,
   expiresAt: sequence,
-  intervalSec: z2.number().int().positive(),
+  intervalSec: z3.number().int().positive(),
   /** The web console page that approves `code`. */
-  verificationUrl: z2.string().url()
+  verificationUrl: z3.string().url()
 });
-var connectPollRequestSchema = z2.strictObject({ deviceCode: z2.string().min(32).max(160) });
-var connectPendingResponseSchema = z2.strictObject({
-  hostname: z2.string(),
-  os: z2.string(),
-  softwareVersion: z2.string(),
+var connectPollRequestSchema = z3.strictObject({ deviceCode: z3.string().min(32).max(160) });
+var connectPendingResponseSchema = z3.strictObject({
+  hostname: z3.string(),
+  os: z3.string(),
+  softwareVersion: z3.string(),
   requestedAt: sequence,
   expiresAt: sequence
 });
-var connectApproveRequestSchema = z2.strictObject({
-  code: z2.string().min(8).max(16),
+var connectApproveRequestSchema = z3.strictObject({
+  code: z3.string().min(8).max(16),
   audience: audienceSchema,
-  hubEpoch: z2.string().optional()
+  hubEpoch: z3.string().optional()
 });
-var connectDenyRequestSchema = z2.strictObject({ code: z2.string().min(8).max(16) });
+var connectDenyRequestSchema = z3.strictObject({ code: z3.string().min(8).max(16) });
 export {
   CALIBRATION_MIN_RUNS,
   CALIBRATION_WINDOW_DAYS,
@@ -723,8 +920,14 @@ export {
   connectStartResponseSchema,
   controlRecordSchema,
   conversationContinuationCapability,
+  defaultDeliveryWorkflow,
   delegationSchema,
   delegationTokenPrefix,
+  deliveredCommandSchema,
+  deliveryEvidenceKindSchema,
+  deliveryStageSchema,
+  deliveryTransitionSchema,
+  deliveryWorkflowSchema,
   forecastOfCap,
   forecastOfClass,
   grantSchema,
@@ -735,6 +938,7 @@ export {
   installReference,
   installedWorkflowsSchema,
   interruptionSchema,
+  orchestratorGuidanceCapability,
   permissionAnswerSchema,
   protocolVersion,
   readableHistory,
@@ -772,6 +976,15 @@ export {
   sequence,
   teamDefaultRequestSchema,
   teamDefaultSchema,
+  trackerCommentSchema,
+  trackerEvidenceSchema,
+  trackerImportPreviewSchema,
+  trackerImportSchema,
+  trackerIssueSchema,
+  trackerOperationSchema,
+  trackerPlanSchema,
+  trackerSnapshotSchema,
+  trackerSourceSchema,
   workflowIdentitySchema,
   workflowInstallCapability,
   workflowName,