@drisp/protocol 0.8.8 → 0.9.0

package/dist/v2.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HMYWICNI.js";
 
 // src/v2.ts
-import { z as z3 } from "zod";
+import { z as z15 } from "zod";
 
 // src/history.ts
 function readableHistory(records) {
@@ -47,90 +47,27 @@ function readableHistory(records) {
   return result;
 }
 
-// src/budget.ts
-import { z } from "zod";
-var SIZE_CLASS_CAPS = {
-  S: 3e6,
-  M: 6e6,
-  L: 12e6
-};
-var SIZE_CLASS_FORECASTS = {
-  S: 15e4,
-  M: 4e5,
-  L: 12e5
-};
-function classOfCap(declaredCap) {
-  if (Number.isNaN(declaredCap) || declaredCap <= SIZE_CLASS_CAPS.S) return "S";
-  if (declaredCap <= SIZE_CLASS_CAPS.M) return "M";
-  return "L";
-}
-function forecastOfCap(declaredCap) {
-  return SIZE_CLASS_FORECASTS[classOfCap(declaredCap)];
-}
-function attemptForecast(declaredCap) {
-  const forecast = forecastOfCap(declaredCap);
-  return declaredCap > 0 ? Math.min(declaredCap, forecast) : forecast;
-}
-function attemptCost(attempt) {
-  const forecast = attemptForecast(attempt.tokenCap);
-  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);
-  return { used, fits: used + input.next <= input.tokenBudget };
-}
-var CALIBRATION_MIN_RUNS = 10;
-var CALIBRATION_WINDOW_DAYS = 90;
-function calibrate(samples) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const { harness, sizeClass, counted } of samples) {
-    if (counted === void 0 || !Number.isFinite(counted) || counted < 0) continue;
-    const key = `${harness}\0${sizeClass}`;
-    const group = byKey.get(key) ?? { harness, sizeClass, counted: [] };
-    group.counted.push(counted);
-    byKey.set(key, group);
-  }
-  const result = {};
-  for (const { harness, sizeClass, counted } of byKey.values()) {
-    if (counted.length < CALIBRATION_MIN_RUNS) continue;
-    const sorted = [...counted].sort((a, b) => a - b);
-    const p90 = sorted[Math.ceil(sorted.length * 0.9) - 1];
-    (result[harness] ??= {})[sizeClass] = { forecast: Math.max(SIZE_CLASS_FORECASTS[sizeClass], p90), runs: sorted.length };
-  }
-  return result;
-}
-var classCalibrationSchema = z.strictObject({
-  S: z.strictObject({ forecast: z.number(), runs: z.number() }).optional(),
-  M: z.strictObject({ forecast: z.number(), runs: z.number() }).optional(),
-  L: z.strictObject({ forecast: z.number(), runs: z.number() }).optional()
-});
-var calibrationSchema = z.record(z.string(), classCalibrationSchema);
-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({
+import { z } from "zod";
+var id = z.string().min(1).max(160);
+var text = z.string().max(1e5);
+var deliveryEvidenceKindSchema = z.enum(["pr_opened", "merged", "staging", "qa_started", "qa_passed", "released"]);
+var deliveryStageSchema = z.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")
+  name: z.string().trim().min(1).max(100),
+  category: z.enum(["backlog", "unstarted", "started", "completed", "canceled"]),
+  behavior: z.enum(["manual", "agent_start", ...deliveryEvidenceKindSchema.options]).default("manual")
 });
-var deliveryTransitionSchema = z2.strictObject({
+var deliveryTransitionSchema = z.strictObject({
   from: id,
   to: id,
-  requires: z2.array(deliveryEvidenceKindSchema).default([])
+  requires: z.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)
+var deliveryWorkflowSchema = z.strictObject({
+  revision: z.number().int().nonnegative(),
+  stages: z.array(deliveryStageSchema).min(1).max(100),
+  transitions: z.array(deliveryTransitionSchema).max(1e4),
+  attentionColumn: z.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" });
@@ -170,79 +107,79 @@ function defaultDeliveryWorkflow() {
   }
   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({
+var trackerSourceSchema = z.strictObject({ workspace: id, id, identifier: id, url: z.string().url() });
+var trackerPlanSchema = z.strictObject({ id, name: z.string().trim().min(1).max(200), description: text.default(""), source: trackerSourceSchema.optional() });
+var trackerCommentSchema = z.strictObject({ id, body: text, author: id, createdAt: z.number(), sourceId: id.optional() });
+var trackerEvidenceSchema = z.strictObject({
   id,
   kind: deliveryEvidenceKindSchema,
   revision: id,
-  reference: z2.string().min(1).max(2e3),
+  reference: z.string().min(1).max(2e3),
   deploymentId: id.optional(),
   runId: id.optional(),
-  createdAt: z2.number(),
+  createdAt: z.number(),
   author: id
 });
-var trackerIssueSchema = z2.strictObject({
+var trackerIssueSchema = z.strictObject({
   id,
   identifier: id,
-  title: z2.string().trim().min(1).max(500),
+  title: z.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(),
+  priority: z.number().int().min(0).max(4),
+  labels: z.array(z.string().max(100)).max(100),
+  blockedBy: z.array(id).max(100),
+  externalBlockers: z.array(z.string().max(2e3)).max(100),
+  agentEligible: z.boolean(),
+  automationHeld: z.boolean(),
   revision: id.nullable(),
-  attention: z2.strictObject({
+  attention: z.strictObject({
     id,
-    message: z2.string().trim().min(1).max(1e4),
+    message: z.string().trim().min(1).max(1e4),
     runId: id.optional(),
-    origin: z2.enum(["manual", "run"]).default("manual")
+    origin: z.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() })),
+  runIds: z.array(id),
+  comments: z.array(trackerCommentSchema),
+  evidence: z.array(trackerEvidenceSchema),
+  history: z.array(z.strictObject({ at: z.number(), actor: id, action: z.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()
+  sourceAssignee: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  version: z.number().int().nonnegative()
 });
-var trackerSnapshotSchema = z2.strictObject({
+var trackerSnapshotSchema = z.strictObject({
   workflow: deliveryWorkflowSchema,
-  issues: z2.array(trackerIssueSchema),
-  plans: z2.array(trackerPlanSchema),
-  members: z2.array(id)
+  issues: z.array(trackerIssueSchema),
+  plans: z.array(trackerPlanSchema),
+  members: z.array(id)
 });
 var issueFields = {
-  title: z2.string().trim().min(1).max(500),
+  title: z.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),
+  priority: z.number().int().min(0).max(4).default(0),
+  labels: z.array(z.string().max(100)).max(100).default([]),
+  blockedBy: z.array(id).max(100).default([]),
+  externalBlockers: z.array(z.string().max(2e3)).max(100).default([]),
+  agentEligible: z.boolean().default(false),
   revision: id.nullable().default(null)
 };
-var trackerImportSchema = z2.strictObject({
+var trackerImportSchema = z.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({
+  stages: z.array(deliveryStageSchema).min(1).max(100),
+  stageMapping: z.record(z.string(), id),
+  adoptWorkflow: z.boolean(),
+  plans: z.array(z.strictObject({ source: trackerSourceSchema, name: z.string().min(1).max(200), description: text })).max(500),
+  issues: z.array(z.strictObject({
     source: trackerSourceSchema,
     title: issueFields.title,
     description: text,
@@ -250,20 +187,20 @@ var trackerImportSchema = z2.strictObject({
     planId: id.nullable(),
     parentId: id.nullable(),
     assignee: id.nullable(),
-    sourceAssignee: z2.string().optional(),
+    sourceAssignee: z.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()
+    blockedBy: z.array(id).max(100),
+    externalBlockers: z.array(z.string().max(2e3)).max(100).default([]),
+    comments: z.array(trackerCommentSchema).max(1e3),
+    createdAt: z.number()
   })).max(2e3),
-  omissions: z2.array(z2.string().max(2e3)).max(500).default([])
+  omissions: z.array(z.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({
+var trackerOperationSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("tracker.sync") }),
+  z.strictObject({ kind: z.literal("issue.create"), id: id.max(147), stageId: id.optional(), ...issueFields }),
+  z.strictObject({ kind: z.literal("issue.update"), id, version: z.number().int(), changes: trackerIssueSchema.pick({
     title: true,
     description: true,
     planId: true,
@@ -276,28 +213,2693 @@ var trackerOperationSchema = z2.discriminatedUnion("kind", [
     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({
+  z.strictObject({ kind: z.literal("plan.save"), ...trackerPlanSchema.shape }),
+  z.strictObject({ kind: z.literal("workflow.save"), workflow: deliveryWorkflowSchema, replacements: z.record(z.string(), id).default({}) }),
+  z.strictObject({ kind: z.literal("issue.transition"), id, version: z.number().int(), stageId: id }),
+  z.strictObject({ kind: z.literal("issue.attention"), id, version: z.number().int(), message: z.string().trim().min(1).max(1e4), runId: id.optional() }),
+  z.strictObject({ kind: z.literal("issue.resolve"), id, version: z.number().int(), attentionId: id }),
+  z.strictObject({ kind: z.literal("issue.resume"), id, version: z.number().int() }),
+  z.strictObject({ kind: z.literal("issue.revision"), id, version: z.number().int(), revision: id, runId: id }),
+  z.strictObject({ kind: z.literal("issue.comment"), id, commentId: id, body: text }),
+  z.strictObject({ kind: z.literal("issue.evidence"), id, evidenceId: id, evidence: trackerEvidenceSchema.omit({ id: true, author: true, createdAt: true }) }),
+  z.strictObject({ kind: z.literal("import.preview"), input: trackerImportSchema }),
+  z.strictObject({ kind: z.literal("import.commit"), previewId: id })
+]);
+var trackerImportPreviewSchema = z.strictObject({
   previewId: id,
-  creates: z2.number().int(),
-  skips: z2.number().int(),
-  plans: z2.number().int(),
-  omissions: z2.array(z2.string())
+  creates: z.number().int(),
+  skips: z.number().int(),
+  plans: z.number().int(),
+  omissions: z.array(z.string())
+});
+
+// src/work.ts
+import { z as z2 } from "zod";
+var id2 = z2.string().min(1).max(160);
+var timestamp = z2.iso.datetime();
+var title = z2.string().trim().min(1).max(500);
+var markdown = z2.string().max(1e5);
+var version = z2.number().int().nonnegative();
+var workCommandVersion = 1;
+var workPrioritySchema = z2.enum(["none", "low", "normal", "high", "urgent"]);
+var workLifecycleSchema = z2.enum(["active", "archived", "deleted"]);
+var workActorSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("human"), memberId: id2 }),
+  z2.strictObject({ kind: z2.literal("agent"), runId: id2 }),
+  z2.strictObject({ kind: z2.literal("system"), component: id2 }),
+  z2.strictObject({ kind: z2.literal("external"), principalId: id2 })
+]);
+var workRefSchema = z2.strictObject({ teamId: id2, id: id2 });
+var workAutomationSchema = z2.object({
+  state: z2.enum(["active", "held"]),
+  // `reopened` (DRI-304): a transition out of a completed or canceled status holds automation until resumed.
+  reason: z2.enum([
+    "manual_correction",
+    "migration",
+    "scope_revised",
+    "candidate_changed",
+    "reopened",
+    // `deployment_changed` (DRI-299): a verified deployment of the current candidate was replaced or retired.
+    "deployment_changed",
+    // `imported` (DRI-306): an imported Issue placed at a status other than the initial one, until a member resumes.
+    "imported"
+  ]).nullable(),
+  heldBy: workActorSchema.nullable(),
+  heldAt: timestamp.nullable(),
+  activityId: id2.nullable()
+});
+var workDeliveryRefSchema = z2.object({
+  workflowId: id2,
+  workflowRevision: version,
+  statusId: id2,
+  automation: workAutomationSchema
+});
+var workScopeRevisionRefSchema = z2.object({ id: id2, number: z2.number().int().positive() });
+var workIssueSchema = z2.object({
+  id: id2,
+  teamId: id2,
+  number: z2.number().int().positive(),
+  identifier: id2,
+  title: z2.string(),
+  description: z2.string(),
+  priority: workPrioritySchema,
+  creator: workActorSchema,
+  threadId: id2,
+  scopeRevision: workScopeRevisionRefSchema,
+  delivery: workDeliveryRefSchema.nullable(),
+  planId: id2.nullable(),
+  parentId: id2.nullable(),
+  lifecycle: workLifecycleSchema,
+  version,
+  createdAt: timestamp,
+  updatedAt: timestamp
+});
+var workPlanSchema = z2.object({
+  id: id2,
+  teamId: id2,
+  number: z2.number().int().positive(),
+  title: z2.string(),
+  description: z2.string(),
+  creator: workActorSchema,
+  threadId: id2,
+  lifecycle: workLifecycleSchema,
+  version,
+  createdAt: timestamp,
+  updatedAt: timestamp
+});
+var workScopeRevisionSchema = z2.object({
+  id: id2,
+  issueId: id2,
+  number: z2.number().int().positive(),
+  title: z2.string(),
+  description: z2.string(),
+  recordedBy: workActorSchema,
+  recordedAt: timestamp,
+  commandId: id2
+});
+var workActivityKindSchema = z2.enum([
+  "issue.created",
+  "issue.edited",
+  "plan.created",
+  "plan.edited",
+  "issue.delivery_changed",
+  "issue.delivery_migrated",
+  "issue.automation_resumed",
+  "issue.automation_held",
+  "workflow.created",
+  "workflow.published",
+  "workflow.activated",
+  // Plans and sub-Issue trees (DRI-296).
+  "plan.archived",
+  "plan.unarchived",
+  "issue.plan_changed",
+  "issue.parent_changed",
+  // Lifecycle and tombstones (DRI-304).
+  "issue.archived",
+  "issue.deleted",
+  "issue.restored",
+  "plan.deleted",
+  "plan.restored",
+  // Import commit (DRI-306): an Issue's import provenance and the delivery status it was placed at, as an assertion.
+  "issue.imported"
+]);
+var workActivitySchema = z2.object({
+  id: id2,
+  seq: z2.number().int().positive(),
+  teamId: id2,
+  subject: z2.object({ kind: z2.enum(["issue", "plan", "workflow"]), id: id2 }),
+  kind: workActivityKindSchema,
+  actor: workActorSchema,
+  operation: z2.object({ commandId: id2, type: z2.string() }),
+  at: timestamp,
+  /** Field name → `{from, to}`; `from` is null on creation. */
+  changes: z2.record(z2.string(), z2.object({ from: z2.json(), to: z2.json() }))
+});
+var workDeliverySlugSchema = z2.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var workDeliveryStatusCategorySchema = z2.enum(["backlog", "unstarted", "started", "completed", "canceled"]);
+var workDeliveryRequirementSchema = z2.string().max(120).regex(/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/);
+var workDeliveryGateSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("manual") }),
+  z2.strictObject({ kind: z2.literal("evidence"), requirement: workDeliveryRequirementSchema, humanAcceptance: z2.boolean().default(false) })
+]);
+var statusName = z2.string().trim().min(1).max(100);
+var workDeliveryWorkflowDefinitionSchema = z2.strictObject({
+  name: title,
+  statuses: z2.array(z2.strictObject({ id: workDeliverySlugSchema, name: statusName, category: workDeliveryStatusCategorySchema })).min(1).max(100),
+  /** Every non-retired status exactly once. Presentation only: it defines neither transitions nor creation. */
+  order: z2.array(workDeliverySlugSchema).max(100),
+  /** Where a new Issue starts. Independent of the order. */
+  initialStatusId: workDeliverySlugSchema,
+  /** The only legal moves. A status reachable from several others lists them in `from`. */
+  transitions: z2.array(z2.strictObject({
+    id: workDeliverySlugSchema,
+    from: z2.array(workDeliverySlugSchema).min(1).max(100),
+    to: workDeliverySlugSchema,
+    /** No gates means none: the move is legal for anyone whenever it leaves the current status. */
+    gates: z2.array(workDeliveryGateSchema).max(16).default([]),
+    /**
+     * Whether a member taking this transition manually holds automation. True (the default) for a correction;
+     * false for a step a person is meant to take, such as triage or release. Automatic advancement never holds.
+     */
+    holdsAutomation: z2.boolean().default(true)
+  })).max(500),
+  /** Which transitions automation may take. A transition with a `manual` gate cannot be one of them. */
+  automation: z2.strictObject({ transitionIds: z2.array(workDeliverySlugSchema).max(500).default([]) })
+});
+var workDeliveryMigrationMappingSchema = z2.record(workDeliverySlugSchema, workDeliverySlugSchema);
+var workDeliveryStatusSchema = z2.object({
+  id: id2,
+  name: z2.string(),
+  category: workDeliveryStatusCategorySchema,
+  /** A retired status keeps its identity so history stays readable; no Issue occupies it. */
+  retired: z2.boolean()
+});
+var workDeliveryTransitionSchema = z2.object({
+  id: id2,
+  from: z2.array(id2),
+  to: id2,
+  gates: z2.array(workDeliveryGateSchema),
+  holdsAutomation: z2.boolean().default(true)
+});
+var workDeliveryWorkflowRevisionSchema = z2.object({
+  workflowId: id2,
+  teamId: id2,
+  revision: z2.number().int().positive(),
+  name: z2.string(),
+  statuses: z2.array(workDeliveryStatusSchema),
+  order: z2.array(id2),
+  initialStatusId: id2,
+  transitions: z2.array(workDeliveryTransitionSchema),
+  automation: z2.object({ transitionIds: z2.array(id2) }),
+  publishedBy: workActorSchema,
+  publishedAt: timestamp,
+  commandId: id2
+});
+var workDeliveryWorkflowSchema = z2.object({
+  id: id2,
+  teamId: id2,
+  number: z2.number().int().positive(),
+  name: z2.string(),
+  active: z2.boolean(),
+  currentRevision: z2.number().int().positive(),
+  version,
+  createdAt: timestamp,
+  updatedAt: timestamp
+});
+var workDeliveryMigrationSchema = z2.object({
+  id: id2,
+  seq: z2.number().int().positive(),
+  teamId: id2,
+  kind: z2.enum(["bootstrap", "revision", "activation"]),
+  from: z2.object({ workflowId: id2, revision: z2.number().int().positive() }).nullable(),
+  to: z2.object({ workflowId: id2, revision: z2.number().int().positive() }),
+  mapping: z2.record(z2.string(), z2.string()),
+  issueCount: z2.number().int().nonnegative(),
+  remappedCount: z2.number().int().nonnegative(),
+  recordedBy: workActorSchema,
+  recordedAt: timestamp,
+  commandId: id2
+});
+var workDeliveryGateFindingSchema = z2.object({ gate: z2.number().int().nonnegative(), kind: z2.string(), reason: z2.string() });
+var workIssueTransitionsSchema = z2.object({
+  issueId: id2,
+  workflowId: id2,
+  workflowRevision: z2.number().int().positive(),
+  statusId: id2,
+  automation: workAutomationSchema,
+  transitions: z2.array(z2.object({
+    id: id2,
+    to: id2,
+    automatic: z2.boolean(),
+    /** Whether the caller's manual transition would pass every gate now (without an acceptance). */
+    satisfied: z2.boolean(),
+    unmet: z2.array(workDeliveryGateFindingSchema)
+  }))
+});
+var workPageSchema = (item) => z2.object({ items: z2.array(item), nextCursor: z2.string().nullable() });
+var workIssuePageSchema = workPageSchema(workIssueSchema);
+var workPlanPageSchema = workPageSchema(workPlanSchema);
+var workActivityPageSchema = workPageSchema(workActivitySchema);
+var workScopeRevisionPageSchema = workPageSchema(workScopeRevisionSchema);
+var workDeliveryWorkflowPageSchema = workPageSchema(workDeliveryWorkflowSchema);
+var workDeliveryWorkflowRevisionPageSchema = workPageSchema(workDeliveryWorkflowRevisionSchema);
+var workDeliveryMigrationPageSchema = workPageSchema(workDeliveryMigrationSchema);
+var workPageLimits = { default: 50, max: 200 };
+var envelope = {
+  version: z2.literal(workCommandVersion),
+  /** The caller's idempotency key, retained for retries. Scoped by Team and the authenticated principal. */
+  commandId: z2.string().min(1).max(200),
+  /** The Team the command is for; it must be the Team of the route. */
+  teamId: id2
+};
+var issueTarget = z2.strictObject({ kind: z2.literal("issue"), id: id2 });
+var planTarget = z2.strictObject({ kind: z2.literal("plan"), id: id2 });
+var workflowTarget = z2.strictObject({ kind: z2.literal("workflow"), id: id2 });
+var candidateId = id2.nullable().default(null);
+var lifecycleReason = z2.strictObject({ reason: z2.string().trim().min(1).max(2e3).nullable().default(null) });
+var workCommandSchema = z2.discriminatedUnion("type", [
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.create"),
+    payload: z2.strictObject({
+      title,
+      description: markdown.default(""),
+      priority: workPrioritySchema.default("none"),
+      plan: workRefSchema.nullable().default(null),
+      parent: workRefSchema.nullable().default(null)
+    })
+  }),
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.edit"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({
+      title: title.optional(),
+      description: markdown.optional(),
+      priority: workPrioritySchema.optional(),
+      /**
+       * Whether this edit changes the requirements being delivered. `revise` publishes a new scope revision;
+       * `unchanged` (a typo, a retitle, a priority change) does not. Required: the caller decides, never inference.
+       */
+      scope: z2.enum(["revise", "unchanged"])
+    })
+  }),
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.create"),
+    payload: z2.strictObject({ title, description: markdown.default("") })
+  }),
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.edit"),
+    target: planTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ title: title.optional(), description: markdown.optional() })
+  }),
+  // ── Plans and sub-Issue trees (DRI-296) ──
+  /**
+   * Archives an active Plan. Its Issues keep their membership, versions and Activity; an archived Plan accepts no
+   * new member Issue and no edit until it is unarchived. Deletion and tombstones are DRI-304's.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.archive"),
+    target: planTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({})
+  }),
+  /** Makes an archived Plan active again, with the same identity, number and Thread. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.unarchive"),
+    target: planTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({})
+  }),
+  /**
+   * Moves an Issue into an active Plan of its Team, or out of its Plan (`plan: null`). An Issue has zero or one Plan.
+   * `expectedVersion` is the Issue's; the Plans' versions and Activity do not change.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.set_plan"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ plan: workRefSchema.nullable() })
+  }),
+  /**
+   * Sets an Issue's one parent to an active Issue of its Team, or clears it (`parent: null`). The Issue's `parentId`
+   * is the only record of parentage. Refused when it would make the Issue its own parent (`self_parent`) or its own
+   * ancestor (`hierarchy_cycle`). It changes neither Issue's Plan, delivery status nor the parent's version.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.set_parent"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ parent: workRefSchema.nullable() })
+  }),
+  // ── end DRI-296 ──
+  // ── Lifecycle and tombstones (DRI-304) ──
+  /**
+   * Archives an active Issue. It keeps its delivery status, Plan, parent, Thread and source bindings; while archived
+   * it takes no ordinary edit (`not_active`). Refused while an execution reservation is held (`issue_occupied`).
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.archive"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: lifecycleReason
+  }),
+  /**
+   * Tombstones an active or archived Issue (soft delete). It keeps its ID, number (never reused), Thread, source keys
+   * and history; every ordinary edit is then `tombstoned`, and an import cannot recreate it. Refused while an
+   * execution reservation is held (`issue_occupied`). It cancels, reparents or moves nothing else.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.delete"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: lifecycleReason
+  }),
+  /** Brings an archived or tombstoned Issue back to `active`, explicitly and attributed. The only way back. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.restore"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: lifecycleReason
+  }),
+  /** Tombstones an active or archived Plan. Its Issues keep their membership; it accepts no new member. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.delete"),
+    target: planTarget,
+    expectedVersion: version,
+    payload: lifecycleReason
+  }),
+  /** Brings an archived or tombstoned Plan back to `active`. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("plan.restore"),
+    target: planTarget,
+    expectedVersion: version,
+    payload: lifecycleReason
+  }),
+  // ── end DRI-304 ──
+  /**
+   * A member's manual delivery transition. It passes the same gates as automation and then holds automation.
+   * `acceptance` records an audited human acceptance for evidence gates that allow one; `candidateId` names the
+   * candidate whose evidence the gates evaluate (DRI-298).
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.transition"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({
+      transitionId: workDeliverySlugSchema,
+      candidateId,
+      acceptance: z2.strictObject({ reason: z2.string().trim().min(1).max(2e3) }).nullable().default(null)
+    })
+  }),
+  /**
+   * Automatic advancement: take the one eligible automatic transition out of the current status. Refused while
+   * automation is held; more than one eligible transition needs an explicit `choice`.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.advance"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ choice: workDeliverySlugSchema.nullable().default(null), candidateId })
+  }),
+  /** Ends an automation hold explicitly and reevaluates which automatic transitions are now eligible. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("issue.resume"),
+    target: issueTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({})
+  }),
+  /** A new, inactive delivery workflow with its first revision. Team admin authority. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("workflow.create"),
+    payload: workDeliveryWorkflowDefinitionSchema
+  }),
+  /**
+   * Publishes the next immutable revision of a workflow. `expectedVersion` is the workflow's version, so a stale
+   * edit is refused. A status left out is retired; an occupied one needs a `migration` replacement.
+   */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("workflow.publish"),
+    target: workflowTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ definition: workDeliveryWorkflowDefinitionSchema, migration: workDeliveryMigrationMappingSchema.default({}) })
+  }),
+  /** Makes a workflow the Team's active one, moving every Issue by an explicit mapping of its occupied statuses. */
+  z2.strictObject({
+    ...envelope,
+    type: z2.literal("workflow.activate"),
+    target: workflowTarget,
+    expectedVersion: version,
+    payload: z2.strictObject({ migration: workDeliveryMigrationMappingSchema.default({}) })
+  })
+]);
+var workCommandResultSchema = z2.object({
+  commandId: id2,
+  type: z2.string(),
+  teamId: id2,
+  status: z2.enum(["accepted", "completed"]),
+  replayed: z2.boolean(),
+  recordedAt: timestamp,
+  activityId: id2,
+  outcome: z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("issue"), issue: workIssueSchema }),
+    z2.object({ kind: z2.literal("plan"), plan: workPlanSchema }),
+    z2.object({
+      kind: z2.literal("workflow"),
+      workflow: workDeliveryWorkflowSchema,
+      revision: workDeliveryWorkflowRevisionSchema,
+      migration: workDeliveryMigrationSchema.nullable()
+    })
+  ])
+});
+var workErrorCodes = [
+  "unauthorized",
+  "forbidden",
+  "not_found",
+  "invalid_request",
+  "payload_too_large",
+  "team_mismatch",
+  "foreign_team_reference",
+  "unknown_reference",
+  "version_conflict",
+  "idempotency_conflict",
+  "no_change",
+  "not_active",
+  // Delivery workflows (DRI-297). `invalid_workflow` carries `reason` and `subject`; `migration_required` the
+  // unmapped `statuses`; `gate_unsatisfied` the `transitionId` and `unmet` findings; `ambiguous_transition` the
+  // `eligible` transition IDs; `no_eligible_transition` each automatic `candidates` entry with its `unmet` findings.
+  "invalid_workflow",
+  "migration_required",
+  "transition_not_allowed",
+  "gate_unsatisfied",
+  "ambiguous_transition",
+  "no_eligible_transition",
+  "automation_held",
+  // Plans and sub-Issue trees (DRI-296): an Issue named as its own parent, or a parent that is its descendant.
+  "self_parent",
+  "hierarchy_cycle",
+  // Lifecycle and tombstones (DRI-304): an ordinary edit of a deleted Issue or Plan; archival or deletion of an
+  // Issue whose execution reservation is held (with `owner` and `reservation` once DRI-310 supplies them).
+  "tombstoned",
+  "issue_occupied",
+  // Restoring an Issue whose Plan or parent is a tombstone: restore that first.
+  "plan_tombstoned",
+  "parent_tombstoned"
+];
+
+// src/work-attention.ts
+import { z as z3 } from "zod";
+var id3 = z3.string().min(1).max(160);
+var timestamp2 = z3.iso.datetime();
+var version2 = z3.number().int().nonnegative();
+var message = z3.string().trim().min(1).max(1e4);
+var workManualAttentionReasonSchema = z3.enum(["requirements", "decision", "approval", "access", "blocked", "other"]);
+var workRunAttentionReasonSchema = z3.enum(["permission", "question", "guidance", "recovery"]);
+var workAttentionReasonSchema = z3.enum([...workManualAttentionReasonSchema.options, ...workRunAttentionReasonSchema.options]);
+var workAttentionRunRefSchema = z3.object({
+  runId: id3,
+  interruptionId: id3.nullable(),
+  interruptionRevision: z3.number().int().positive().nullable()
+});
+var workAttentionResolutionSchema = z3.object({
+  kind: z3.enum(["answered", "dismissed", "run_interruption_closed"]),
+  note: z3.string().nullable(),
+  /** For `run_interruption_closed`: what the Run did. */
+  runState: z3.enum(["answered", "closed", "superseded"]).nullable(),
+  by: workActorSchema,
+  at: timestamp2,
+  commandId: id3
+});
+var workAttentionRequestSchema = z3.object({
+  id: id3,
+  teamId: id3,
+  issueId: id3,
+  origin: z3.enum(["manual", "run"]),
+  reason: workAttentionReasonSchema,
+  message: z3.string(),
+  /** Who must act. Only human requests exist today; they make up the Issue's Needs Human projection. */
+  respondent: z3.enum(["human"]),
+  /** Attributed requester: the member, or the Run (`agent`) whose interruption it projects. */
+  requestedBy: workActorSchema,
+  run: workAttentionRunRefSchema.nullable(),
+  state: z3.enum(["open", "resolved"]),
+  resolution: workAttentionResolutionSchema.nullable(),
+  /** The request's own optimistic version; the Issue's version never moves with attention. */
+  version: z3.number().int().positive(),
+  createdAt: timestamp2,
+  updatedAt: timestamp2
+});
+var workExecutionPolicySchema = z3.object({
+  issueId: id3,
+  teamId: id3,
+  agentEligible: z3.boolean(),
+  hold: z3.object({ reason: z3.string(), heldBy: workActorSchema, heldAt: timestamp2, commandId: id3 }).nullable(),
+  version: version2,
+  updatedAt: timestamp2.nullable()
+});
+var workAttentionActivityKindSchema = z3.enum([
+  "attention.requested",
+  "attention.updated",
+  "attention.resolved",
+  "execution_policy.held",
+  "execution_policy.resumed",
+  "execution_policy.eligibility_changed"
+]);
+var workAttentionActivitySchema = workActivitySchema.extend({
+  subject: z3.object({ kind: z3.enum(["attention", "execution_policy"]), id: id3 }),
+  kind: workAttentionActivityKindSchema
+});
+var workAttentionRequestPageSchema = workPageSchema(workAttentionRequestSchema);
+var workAttentionActivityPageSchema = workPageSchema(workAttentionActivitySchema);
+var envelope2 = { version: z3.literal(workCommandVersion), commandId: z3.string().min(1).max(200), teamId: id3 };
+var issueTarget2 = z3.strictObject({ kind: z3.literal("issue"), id: id3 });
+var workAttentionCommandSchema = z3.discriminatedUnion("type", [
+  /** A member asks for human attention on an Issue. It edits neither the Issue nor its delivery. */
+  z3.strictObject({
+    ...envelope2,
+    type: z3.literal("attention.request"),
+    target: issueTarget2,
+    payload: z3.strictObject({
+      reason: workManualAttentionReasonSchema,
+      message,
+      /** Context only: a Run the member can see. It is not an interruption and answers nothing. */
+      runId: id3.nullable().default(null)
+    })
+  }),
+  /** A member resolves one request at its version. A Run-origin request whose interruption is pending is refused. */
+  z3.strictObject({
+    ...envelope2,
+    type: z3.literal("attention.resolve"),
+    target: z3.strictObject({ kind: z3.literal("attention"), id: id3 }),
+    expectedVersion: z3.number().int().positive(),
+    payload: z3.strictObject({ resolution: z3.enum(["answered", "dismissed"]), note: z3.string().max(1e4).nullable().default(null) })
+  }),
+  /**
+   * Reconciles the Issue's Run-origin requests from the Run's authoritative state (an organization-visible Run; the
+   * Issue is the caller's choice until DRI-310 binds Runs to Issues): opens a request for its pending
+   * human interruption, refreshes one whose revision moved, and resolves those the Run has answered, closed or
+   * replaced. The same interruption is always the same request.
+   */
+  z3.strictObject({ ...envelope2, type: z3.literal("attention.sync_run"), target: issueTarget2, payload: z3.strictObject({ runId: id3 }) }),
+  z3.strictObject({
+    ...envelope2,
+    type: z3.literal("execution_policy.hold"),
+    target: issueTarget2,
+    expectedVersion: version2,
+    payload: z3.strictObject({ reason: z3.string().trim().min(1).max(2e3) })
+  }),
+  z3.strictObject({
+    ...envelope2,
+    type: z3.literal("execution_policy.resume"),
+    target: issueTarget2,
+    expectedVersion: version2,
+    payload: z3.strictObject({})
+  }),
+  z3.strictObject({
+    ...envelope2,
+    type: z3.literal("execution_policy.set_agent_eligibility"),
+    target: issueTarget2,
+    expectedVersion: version2,
+    payload: z3.strictObject({ agentEligible: z3.boolean() })
+  })
+]);
+var workAttentionCommandTypes = workAttentionCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkAttentionCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workAttentionCommandTypes.includes(type);
+}
+var workAttentionCommandResultSchema = z3.object({
+  commandId: id3,
+  type: z3.string(),
+  teamId: id3,
+  status: z3.enum(["accepted", "completed"]),
+  replayed: z3.boolean(),
+  recordedAt: timestamp2,
+  activityId: id3,
+  outcome: z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("attention"), attention: workAttentionRequestSchema }),
+    /** The requests a reconciliation opened, refreshed or resolved, in that order of decision. */
+    z3.object({ kind: z3.literal("attention_sync"), requests: z3.array(workAttentionRequestSchema) }),
+    z3.object({ kind: z3.literal("execution_policy"), policy: workExecutionPolicySchema })
+  ])
+});
+var workAttentionErrorCodes = ["not_open", "interruption_pending", "run_not_team_visible"];
+
+// src/work-sources.ts
+import { z as z4 } from "zod";
+var id4 = z4.string().min(1).max(160);
+var timestamp3 = z4.iso.datetime();
+var sourceTimestamp = z4.iso.datetime({ offset: true });
+var version3 = z4.number().int().nonnegative();
+var token = z4.string().min(1).max(200).regex(/^\S(?:.*\S)?$/, "no surrounding whitespace");
+var externalId = z4.string().min(1).max(500);
+var readable = z4.string().trim().min(1).max(500);
+var url = z4.url({ protocol: /^https?$/ }).max(2e3);
+var workSourceContainerSchema = z4.strictObject({
+  kind: token,
+  id: externalId,
+  name: readable.nullable().default(null)
+});
+var workSourceTargetSchema = z4.strictObject({ kind: z4.enum(["issue", "plan"]), id: id4 });
+var workSourceKeySchema = z4.strictObject({ spaceId: id4, entityKind: token, idNamespace: token, externalId });
+var workSourceSpaceSchema = z4.object({
+  id: id4,
+  teamId: id4,
+  provider: z4.string(),
+  instance: z4.string(),
+  workspaceId: z4.string(),
+  displayName: z4.string().nullable(),
+  recordedBy: workActorSchema,
+  version: version3,
+  createdAt: timestamp3,
+  updatedAt: timestamp3
+});
+var workSourcePrincipalSchema = z4.object({
+  id: id4,
+  teamId: id4,
+  spaceId: id4,
+  idNamespace: z4.string(),
+  externalId: z4.string(),
+  displayName: z4.string().nullable(),
+  /** The member this external identity is explicitly mapped to, or null. Never inferred from a name or email. */
+  memberId: id4.nullable(),
+  recordedBy: workActorSchema,
+  version: version3,
+  createdAt: timestamp3,
+  updatedAt: timestamp3
+});
+var workSourceReferenceSchema = z4.object({
+  id: id4,
+  teamId: id4,
+  key: z4.object({ spaceId: id4, entityKind: z4.string(), idNamespace: z4.string(), externalId: z4.string() }),
+  containers: z4.array(z4.object({ kind: z4.string(), id: z4.string(), name: z4.string().nullable() })),
+  /** The readable source identifier as last observed (a mutable alias, not identity); null when unknown or empty. */
+  identifier: z4.string().nullable(),
+  url: z4.string().nullable(),
+  sourceCreatedAt: z4.string().nullable(),
+  sourceUpdatedAt: z4.string().nullable(),
+  /**
+   * Who authored the source record: an external source principal, or null when unknown. Set once, when the reference
+   * is recorded (an import supplies it); `observe` never changes it.
+   */
+  author: z4.object({ kind: z4.literal("external"), principalId: id4 }).nullable(),
+  /** The member who recorded this reference in Drisp. Distinct from `author`. */
+  recordedBy: workActorSchema,
+  /** The Issue or Plan this reference is explicitly associated with now, or null when detached. */
+  target: z4.object({ kind: z4.enum(["issue", "plan"]), id: id4 }).nullable(),
+  version: version3,
+  createdAt: timestamp3,
+  updatedAt: timestamp3
+});
+var workSourceAliasSchema = z4.object({
+  seq: z4.number().int().positive(),
+  referenceId: id4,
+  kind: z4.enum(["key", "identifier"]),
+  idNamespace: z4.string().nullable(),
+  value: z4.string(),
+  recordedAt: timestamp3,
+  commandId: id4
+});
+var workSourceAssociationSchema = z4.object({
+  seq: z4.number().int().positive(),
+  referenceId: id4,
+  from: workSourceTargetSchema.nullable(),
+  to: workSourceTargetSchema.nullable(),
+  actor: workActorSchema,
+  commandId: id4,
+  activityId: id4,
+  at: timestamp3
+});
+var workSourceActivityKindSchema = z4.enum([
+  "source_space.registered",
+  "source_principal.recorded",
+  "source_principal.mapped",
+  "source_reference.recorded",
+  "source_reference.observed",
+  "source_reference.associated",
+  "source_reference.key_aliased"
+]);
+var workSourceActivitySchema = z4.object({
+  id: id4,
+  seq: z4.number().int().positive(),
+  teamId: id4,
+  subject: z4.object({ kind: z4.enum(["source_space", "source_principal", "source_reference"]), id: id4 }),
+  kind: workSourceActivityKindSchema,
+  actor: workActorSchema,
+  operation: z4.object({ commandId: id4, type: z4.string() }),
+  at: timestamp3,
+  changes: z4.record(z4.string(), z4.object({ from: z4.json(), to: z4.json() }))
+});
+var workSourceSpacePageSchema = workPageSchema(workSourceSpaceSchema);
+var workSourcePrincipalPageSchema = workPageSchema(workSourcePrincipalSchema);
+var workSourceReferencePageSchema = workPageSchema(workSourceReferenceSchema);
+var workSourceAliasPageSchema = workPageSchema(workSourceAliasSchema);
+var workSourceAssociationPageSchema = workPageSchema(workSourceAssociationSchema);
+var workSourceActivityPageSchema = workPageSchema(workSourceActivitySchema);
+var envelope3 = {
+  version: z4.literal(workCommandVersion),
+  commandId: z4.string().min(1).max(200),
+  teamId: id4
+};
+var principalTarget = z4.strictObject({ kind: z4.literal("source_principal"), id: id4 });
+var referenceTarget = z4.strictObject({ kind: z4.literal("source_reference"), id: id4 });
+var associationTarget = z4.strictObject({ kind: z4.enum(["issue", "plan"]), teamId: id4, id: id4 });
+var workSourceCommandSchema = z4.discriminatedUnion("type", [
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_space.register"),
+    payload: z4.strictObject({ provider: token, instance: token, workspaceId: externalId, displayName: readable.nullable().default(null) })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_principal.record"),
+    payload: z4.strictObject({ spaceId: id4, idNamespace: token, externalId, displayName: readable.nullable().default(null) })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_principal.map"),
+    target: principalTarget,
+    expectedVersion: version3,
+    payload: z4.strictObject({ memberId: id4.nullable() })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_reference.record"),
+    payload: z4.strictObject({
+      key: workSourceKeySchema,
+      containers: z4.array(workSourceContainerSchema).max(20).default([]),
+      identifier: readable.nullable().default(null),
+      url: url.nullable().default(null),
+      sourceCreatedAt: sourceTimestamp.nullable().default(null),
+      sourceUpdatedAt: sourceTimestamp.nullable().default(null),
+      /** A source principal in the same space, or null when the author is unknown. */
+      authorPrincipalId: id4.nullable().default(null),
+      target: associationTarget.nullable().default(null)
+    })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_reference.observe"),
+    target: referenceTarget,
+    expectedVersion: version3,
+    payload: z4.strictObject({
+      containers: z4.array(workSourceContainerSchema).max(20).optional(),
+      identifier: readable.nullable().optional(),
+      url: url.nullable().optional(),
+      sourceUpdatedAt: sourceTimestamp.nullable().optional()
+    })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_reference.associate"),
+    target: referenceTarget,
+    expectedVersion: version3,
+    payload: z4.strictObject({ to: associationTarget.nullable() })
+  }),
+  z4.strictObject({
+    ...envelope3,
+    type: z4.literal("source_reference.alias_key"),
+    target: referenceTarget,
+    expectedVersion: version3,
+    payload: z4.strictObject({ idNamespace: token, externalId })
+  })
+]);
+var workSourceCommandTypes = workSourceCommandSchema.options.map((option) => option.shape.type.value);
+function isWorkSourceCommand(body) {
+  const type = body?.type;
+  return typeof type === "string" && workSourceCommandTypes.includes(type);
+}
+var workSourceCommandResultSchema = z4.object({
+  commandId: id4,
+  type: z4.string(),
+  teamId: id4,
+  status: z4.enum(["accepted", "completed"]),
+  replayed: z4.boolean(),
+  recordedAt: timestamp3,
+  activityId: id4,
+  outcome: z4.discriminatedUnion("kind", [
+    z4.object({ kind: z4.literal("source_space"), space: workSourceSpaceSchema }),
+    z4.object({ kind: z4.literal("source_principal"), principal: workSourcePrincipalSchema }),
+    z4.object({ kind: z4.literal("source_reference"), reference: workSourceReferenceSchema })
+  ])
+});
+var workSourceErrorCodes = ["source_key_conflict", "unknown_member"];
+
+// src/work-membership.ts
+import { z as z5 } from "zod";
+var id5 = z5.string().min(1).max(160);
+var timestamp4 = z5.iso.datetime();
+var version4 = z5.number().int().nonnegative();
+var workLabelNameSchema = z5.string().trim().min(1).max(80);
+var workLabelColorSchema = z5.string().regex(/^#[0-9a-fA-F]{6}$/);
+var workLabelSchema = z5.object({
+  id: id5,
+  teamId: id5,
+  name: z5.string(),
+  color: z5.string().nullable(),
+  description: z5.string(),
+  creator: workActorSchema,
+  /** Only `active` is produced today; archival and tombstones arrive with DRI-304. */
+  lifecycle: workLifecycleSchema,
+  version: z5.number().int().positive(),
+  createdAt: timestamp4,
+  updatedAt: timestamp4
+});
+var workMembershipRemovalSchema = z5.object({ by: workActorSchema, at: timestamp4, commandId: id5 });
+var workIssueAssigneeSchema = z5.object({
+  id: id5,
+  teamId: id5,
+  issueId: id5,
+  memberId: id5,
+  memberActive: z5.boolean(),
+  assignedBy: workActorSchema,
+  assignedAt: timestamp4,
+  commandId: id5,
+  removal: workMembershipRemovalSchema.nullable()
+});
+var workIssueLabelSchema = z5.object({
+  id: id5,
+  teamId: id5,
+  issueId: id5,
+  labelId: id5,
+  label: workLabelSchema,
+  addedBy: workActorSchema,
+  addedAt: timestamp4,
+  commandId: id5,
+  removal: workMembershipRemovalSchema.nullable()
+});
+var workIssueMembershipSchema = z5.object({
+  issueId: id5,
+  teamId: id5,
+  version: version4,
+  assigneeCount: z5.number().int().nonnegative(),
+  labelCount: z5.number().int().nonnegative(),
+  updatedAt: timestamp4.nullable()
+});
+var workMembershipActivityKindSchema = z5.enum([
+  "issue.assignee_added",
+  "issue.assignee_removed",
+  "issue.label_added",
+  "issue.label_removed",
+  "label.created",
+  "label.edited"
+]);
+var workMembershipActivitySchema = workActivitySchema.extend({
+  subject: z5.object({ kind: z5.enum(["issue_membership", "label"]), id: id5 }),
+  kind: workMembershipActivityKindSchema
+});
+var workLabelPageSchema = workPageSchema(workLabelSchema);
+var workIssueAssigneePageSchema = workPageSchema(workIssueAssigneeSchema);
+var workIssueLabelPageSchema = workPageSchema(workIssueLabelSchema);
+var workMembershipActivityPageSchema = workPageSchema(workMembershipActivitySchema);
+var workLabelIssuePageSchema = workPageSchema(workIssueSchema);
+var envelope4 = { version: z5.literal(workCommandVersion), commandId: z5.string().min(1).max(200), teamId: id5 };
+var issueTarget3 = z5.strictObject({ kind: z5.literal("issue"), id: id5 });
+var membershipVersion = version4;
+var workMembershipCommandSchema = z5.discriminatedUnion("type", [
+  /** Assigns an active member of this Team. A member reference into another Team is `foreign_team_reference`. */
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("issue_membership.assign"),
+    target: issueTarget3,
+    expectedVersion: membershipVersion,
+    payload: z5.strictObject({ member: workRefSchema })
+  }),
+  /** Ends a current assignment, attributed; a member who left the Team can still be unassigned. */
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("issue_membership.unassign"),
+    target: issueTarget3,
+    expectedVersion: membershipVersion,
+    payload: z5.strictObject({ member: workRefSchema })
+  }),
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("issue_membership.add_label"),
+    target: issueTarget3,
+    expectedVersion: membershipVersion,
+    payload: z5.strictObject({ label: workRefSchema })
+  }),
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("issue_membership.remove_label"),
+    target: issueTarget3,
+    expectedVersion: membershipVersion,
+    payload: z5.strictObject({ label: workRefSchema })
+  }),
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("label.create"),
+    payload: z5.strictObject({
+      name: workLabelNameSchema,
+      color: workLabelColorSchema.nullable().default(null),
+      description: z5.string().max(2e3).default("")
+    })
+  }),
+  /** Renames or recolors a label at its version. Every membership follows: they name the label's ID. */
+  z5.strictObject({
+    ...envelope4,
+    type: z5.literal("label.edit"),
+    target: z5.strictObject({ kind: z5.literal("label"), id: id5 }),
+    expectedVersion: z5.number().int().positive(),
+    payload: z5.strictObject({
+      name: workLabelNameSchema.optional(),
+      color: workLabelColorSchema.nullable().optional(),
+      description: z5.string().max(2e3).optional()
+    })
+  })
+]);
+var workMembershipCommandTypes = workMembershipCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkMembershipCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workMembershipCommandTypes.includes(type);
+}
+var workMembershipCommandResultSchema = z5.object({
+  commandId: id5,
+  type: z5.string(),
+  teamId: id5,
+  status: z5.enum(["accepted", "completed"]),
+  replayed: z5.boolean(),
+  recordedAt: timestamp4,
+  activityId: id5,
+  outcome: z5.discriminatedUnion("kind", [
+    z5.object({ kind: z5.literal("assignee"), assignee: workIssueAssigneeSchema, membership: workIssueMembershipSchema }),
+    z5.object({ kind: z5.literal("issue_label"), issueLabel: workIssueLabelSchema, membership: workIssueMembershipSchema }),
+    z5.object({ kind: z5.literal("label"), label: workLabelSchema })
+  ])
+});
+var workMembershipErrorCodes = ["member_inactive", "label_name_taken"];
+
+// src/work-evidence.ts
+import { z as z6 } from "zod";
+var id6 = z6.string().min(1).max(160);
+var timestamp5 = z6.iso.datetime();
+var version5 = z6.number().int().nonnegative();
+var reason = z6.string().trim().min(1).max(2e3);
+var slug = z6.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+var workCandidateArtifactSchema = z6.object({
+  kind: z6.enum(["commit", "pull_request", "branch", "build", "other"]),
+  locator: z6.string().trim().min(1).max(500),
+  revision: z6.string().trim().min(1).max(200),
+  url: z6.string().nullable()
+});
+var workCandidateDeploymentSchema = z6.object({ environment: slug, id: id6 });
+var workCandidateQaProfileSchema = z6.enum(["staging", "pre_merge"]);
+var workCandidateSchema = z6.object({
+  id: id6,
+  teamId: id6,
+  issueId: id6,
+  /** Per Issue, from 1, in proposal order. */
+  number: z6.number().int().positive(),
+  /** The scope revision these artifacts are proposed to satisfy. */
+  scopeRevision: workScopeRevisionRefSchema,
+  artifacts: z6.array(workCandidateArtifactSchema),
+  deployment: workCandidateDeploymentSchema.nullable(),
+  qaProfile: workCandidateQaProfileSchema,
+  proposedBy: workActorSchema,
+  proposedAt: timestamp5,
+  commandId: id6
+});
+var workCandidateSelectionSchema = z6.object({
+  issueId: id6,
+  teamId: id6,
+  candidateId: id6.nullable(),
+  version: version5,
+  selectedBy: workActorSchema.nullable(),
+  selectedAt: timestamp5.nullable(),
+  commandId: id6.nullable()
+});
+var workEvidenceAssignmentSchema = z6.object({
+  ref: z6.string().trim().min(1).max(200),
+  standing: z6.enum(["open", "closed", "superseded"])
+});
+var workEvidenceReferenceSchema = z6.object({ kind: slug, value: z6.string().trim().min(1).max(2e3) });
+var workEvidenceDecisionSchema = z6.object({ by: workActorSchema, at: timestamp5, reason: z6.string(), commandId: id6 });
+var workEvidenceApplicabilitySchema = z6.enum([
+  "applicable",
+  "retracted",
+  "superseded",
+  "reported_after_closure",
+  "stale_scope_revision",
+  "stale_candidate",
+  // Deployments and verification attempts (DRI-299): a source's assertion never applies; evidence about a replaced
+  // or retired deployment, or about a verification attempt that is superseded (or, for a production confirmation,
+  // no longer passed), no longer applies.
+  "source_assertion",
+  "stale_deployment",
+  "stale_attempt"
+]);
+var workEvidenceSourceAssertionSchema = z6.object({ source: slug, ref: z6.string().trim().min(1).max(500) });
+var workEvidenceSchema = z6.object({
+  id: id6,
+  teamId: id6,
+  issueId: id6,
+  /** The fact reported, in requirement form (`pull_request.open`, `pull_request.merged`, `qa.passed`, `run.live`). */
+  kind: workDeliveryRequirementSchema,
+  /** The input tuple the reporter verified. */
+  scopeRevision: workScopeRevisionRefSchema,
+  candidateId: id6.nullable(),
+  /** A deployment record (`dep_…`, DRI-299) of the candidate: for QA, the attempt's; for a release, production's. */
+  deploymentId: id6.nullable(),
+  /**
+   * The verification attempt (`vat_…`, DRI-299) a QA result concludes, or the verified attempt a production
+   * confirmation names (null for a `pre_merge` candidate, verified before merge).
+   */
+  verificationAttemptId: id6.nullable(),
+  runId: id6.nullable(),
+  assignment: workEvidenceAssignmentSchema.nullable(),
+  sourceAssertion: workEvidenceSourceAssertionSchema.nullable(),
+  disposition: z6.enum(["current", "reported_after_closure", "source_assertion"]),
+  /** A member's audited acceptance of evidence reported after closure; only then can it satisfy a gate. */
+  acceptance: workEvidenceDecisionSchema.nullable(),
+  references: z6.array(workEvidenceReferenceSchema),
+  reportedBy: workActorSchema,
+  occurredAt: timestamp5,
+  recordedAt: timestamp5,
+  commandId: id6,
+  supersedes: id6.nullable(),
+  supersededBy: id6.nullable(),
+  retraction: workEvidenceDecisionSchema.nullable(),
+  /** The evidence record's own concurrency version: supersession, retraction and acceptance bump it. */
+  version: z6.number().int().positive(),
+  applicability: workEvidenceApplicabilitySchema
+});
+var workEvidenceAutomationSchema = z6.object({
+  status: z6.enum(["advanced", "held", "no_eligible_transition", "ambiguous_transition", "skipped"]),
+  /** For `skipped`: `not_applicable` (the evidence does not apply to the Issue's current inputs). */
+  reason: z6.string().nullable(),
+  /** For `advanced`: the status reached, the Issue version and the transition's Activity. */
+  statusId: id6.nullable(),
+  issueVersion: version5.nullable(),
+  activityId: id6.nullable(),
+  /** For `ambiguous_transition`: the eligible transition IDs. */
+  eligible: z6.array(id6)
+});
+var workEvidenceActivityKindSchema = z6.enum([
+  "candidate.proposed",
+  "candidate.selected",
+  "evidence.recorded",
+  "evidence.superseded",
+  "evidence.retracted",
+  "evidence.accepted",
+  // A member's production confirmation (DRI-299): the `release.recorded` evidence it records.
+  "production.confirmed"
+]);
+var workEvidenceActivitySchema = workActivitySchema.extend({
+  subject: z6.object({ kind: z6.enum(["candidate", "candidate_selection", "evidence"]), id: id6 }),
+  kind: workEvidenceActivityKindSchema
+});
+var workCandidatePageSchema = workPageSchema(workCandidateSchema);
+var workEvidencePageSchema = workPageSchema(workEvidenceSchema);
+var workEvidenceActivityPageSchema = workPageSchema(workEvidenceActivitySchema);
+var envelope5 = { version: z6.literal(workCommandVersion), commandId: z6.string().min(1).max(200), teamId: id6 };
+var issueTarget4 = z6.strictObject({ kind: z6.literal("issue"), id: id6 });
+var evidenceTarget = z6.strictObject({ kind: z6.literal("evidence"), id: id6 });
+var workEvidenceCommandSchema = z6.discriminatedUnion("type", [
+  /** Proposes an immutable candidate for the Issue's current scope revision. It does not select it. */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("candidate.propose"),
+    target: issueTarget4,
+    payload: z6.strictObject({
+      scopeRevisionId: id6,
+      artifacts: z6.array(z6.strictObject({
+        kind: workCandidateArtifactSchema.shape.kind,
+        locator: workCandidateArtifactSchema.shape.locator,
+        revision: workCandidateArtifactSchema.shape.revision,
+        url: z6.url({ protocol: /^https?$/ }).max(2e3).nullable().default(null)
+      })).min(1).max(20),
+      deployment: z6.strictObject({ environment: slug, id: id6 }).nullable().default(null),
+      qaProfile: workCandidateQaProfileSchema
+    })
+  }),
+  /**
+   * Makes a candidate of the current scope revision the Issue's current one, or none (`null`). `expectedVersion` is
+   * the selection's version. Replacing or clearing a current candidate holds the Issue's automation.
+   */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("candidate.select"),
+    target: issueTarget4,
+    expectedVersion: version5,
+    payload: z6.strictObject({ candidateId: id6.nullable() })
+  }),
+  /**
+   * Records evidence about the input tuple the reporter verified. `supersedes` names the Issue's earlier evidence
+   * this replaces. A member records as themself and cannot name a Run; an in-process reporter supplies its own.
+   */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("evidence.record"),
+    target: issueTarget4,
+    payload: z6.strictObject({
+      kind: workDeliveryRequirementSchema,
+      scopeRevisionId: id6,
+      candidateId: id6.nullable().default(null),
+      deploymentId: id6.nullable().default(null),
+      /** Required for `qa.passed` and `qa.failed` (DRI-299): the attempt the result concludes. */
+      verificationAttemptId: id6.nullable().default(null),
+      runId: id6.nullable().default(null),
+      assignment: z6.strictObject({ ref: workEvidenceAssignmentSchema.shape.ref, standing: workEvidenceAssignmentSchema.shape.standing }).nullable().default(null),
+      occurredAt: timestamp5,
+      references: z6.array(z6.strictObject({ kind: slug, value: workEvidenceReferenceSchema.shape.value })).max(20).default([]),
+      supersedes: id6.nullable().default(null),
+      /** What an imported source said (DRI-299): recorded as history with the disposition `source_assertion`. */
+      sourceAssertion: z6.strictObject({ source: slug, ref: workEvidenceSourceAssertionSchema.shape.ref }).nullable().default(null)
+    })
+  }),
+  /**
+   * A member's production confirmation (DRI-299; root ADR-0017: a Work operation by a human, never a step an
+   * execution waits on). It names the verified attempt on a verification deployment (null only for a `pre_merge`
+   * candidate) and the production deployment of the same, current candidate, and records `release.recorded`
+   * evidence for them, which the Released gate reads. Refused for delegated Run tokens and in-process reporters.
+   */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("production.confirm"),
+    target: issueTarget4,
+    payload: z6.strictObject({
+      verificationAttemptId: id6.nullable(),
+      productionDeploymentId: id6,
+      occurredAt: timestamp5,
+      references: z6.array(z6.strictObject({ kind: slug, value: workEvidenceReferenceSchema.shape.value })).max(20).default([])
+    })
+  }),
+  /** Retracts evidence explicitly, at its version. It stays in history and satisfies nothing. */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("evidence.retract"),
+    target: evidenceTarget,
+    expectedVersion: z6.number().int().positive(),
+    payload: z6.strictObject({ reason })
+  }),
+  /** A member's audited acceptance of evidence reported after closure (ADR-0017), at its version. Human only. */
+  z6.strictObject({
+    ...envelope5,
+    type: z6.literal("evidence.accept"),
+    target: evidenceTarget,
+    expectedVersion: z6.number().int().positive(),
+    payload: z6.strictObject({ reason })
+  })
+]);
+var workEvidenceCommandTypes = workEvidenceCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkEvidenceCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workEvidenceCommandTypes.includes(type);
+}
+var workEvidenceCommandResultSchema = z6.object({
+  commandId: id6,
+  type: z6.string(),
+  teamId: id6,
+  status: z6.enum(["accepted", "completed"]),
+  replayed: z6.boolean(),
+  recordedAt: timestamp5,
+  activityId: id6,
+  outcome: z6.discriminatedUnion("kind", [
+    z6.object({ kind: z6.literal("candidate"), candidate: workCandidateSchema }),
+    /** `issue` is the Issue when the change held its automation, otherwise null. */
+    z6.object({ kind: z6.literal("candidate_selection"), selection: workCandidateSelectionSchema, issue: workIssueSchema.nullable() }),
+    /** `superseded` is the evidence this record replaced; `automation` is null for a retraction or replay of one. */
+    z6.object({
+      kind: z6.literal("evidence"),
+      evidence: workEvidenceSchema,
+      superseded: workEvidenceSchema.nullable(),
+      automation: workEvidenceAutomationSchema.nullable()
+    })
+  ])
+});
+var workEvidenceErrorCodes = ["stale_scope_revision", "evidence_closed", "not_after_closure"];
+
+// src/work-reservations.ts
+import { z as z7 } from "zod";
+var id7 = z7.string().min(1).max(200);
+var timestamp6 = z7.iso.datetime();
+var generation = z7.number().int().positive();
+var workReservationOwnerSchema = z7.object({ kind: z7.literal("run"), runId: id7 });
+var workOutstandingEffectSchema = z7.object({ id: id7, summary: z7.string().max(2e3) });
+var workExecutionReservationSchema = z7.object({
+  id: id7,
+  teamId: id7,
+  issueId: id7,
+  owner: workReservationOwnerSchema,
+  /** The Issue's ownership generation this reservation was acquired at. */
+  generation,
+  state: z7.enum(["held", "released"]),
+  /** The authority admission granted the owner; every binding inherits a subset of it. */
+  authority: z7.array(z7.string()),
+  /** The versions the work was admitted against. */
+  scopeRevision: z7.object({ id: id7, number: z7.number().int().positive() }),
+  delivery: z7.object({ workflowId: id7, workflowRevision: z7.number().int().positive(), statusId: id7 }),
+  /** The reservation released before this one on the same Issue (a successor's predecessor), if any. */
+  predecessorId: id7.nullable(),
+  /** Set when the Issue was cancelled while occupied: a recorded request, which releases nothing. */
+  cancelRequest: z7.object({ by: workActorSchema, at: timestamp6, commandId: id7, activityId: id7 }).nullable(),
+  closure: z7.object({
+    outcome: z7.enum(["run_closed", "accepted", "cancelled", "failed", "legacy_run_closed"]),
+    by: workActorSchema,
+    at: timestamp6,
+    commandId: id7,
+    /** The Issue's generation after closure: every binding of `generation` is stale from here on. */
+    releasedGeneration: generation,
+    outstandingEffects: z7.array(workOutstandingEffectSchema),
+    acknowledgement: z7.object({ reason: z7.string() }).nullable()
+  }).nullable(),
+  acquiredBy: workActorSchema,
+  acquiredAt: timestamp6,
+  releasedAt: timestamp6.nullable(),
+  version: z7.number().int().positive()
+});
+var workExecutionBindingSchema = z7.object({
+  id: id7,
+  teamId: id7,
+  reservationId: id7,
+  issueId: id7,
+  runId: id7,
+  /** The assignment the Run carries out; for a Run admitted by a start, the start's own activation. */
+  assignmentId: id7,
+  role: z7.string(),
+  generation,
+  /** The applicable input version: the scope revision this Run works against. */
+  scopeRevision: z7.object({ id: id7, number: z7.number().int().positive() }),
+  authority: z7.array(z7.string()),
+  boundBy: workActorSchema,
+  boundAt: timestamp6,
+  commandId: id7
+});
+var workIssueReservationSchema = z7.object({
+  issueId: id7,
+  teamId: id7,
+  generation: z7.number().int().nonnegative(),
+  occupied: z7.boolean(),
+  reservation: workExecutionReservationSchema.nullable()
+});
+var workLegacyAliasSchema = z7.object({
+  teamId: id7,
+  alias: id7,
+  issueId: id7,
+  recordedBy: workActorSchema,
+  recordedAt: timestamp6,
+  commandId: id7
+});
+var workReservationActivityKindSchema = z7.enum([
+  "execution.reserved",
+  "execution.run_bound",
+  "execution.cancel_requested",
+  "execution.released",
+  // Recorded before DRI-364 only.
+  "execution.state_reported",
+  "execution.closed",
+  "execution.legacy_released",
+  "legacy_alias.recorded"
+]);
+var workReservationActivitySchema = workActivitySchema.extend({
+  subject: z7.object({ kind: z7.enum(["reservation", "legacy_alias"]), id: id7 }),
+  kind: workReservationActivityKindSchema
+});
+var workExecutionReservationPageSchema = workPageSchema(workExecutionReservationSchema);
+var workExecutionBindingPageSchema = workPageSchema(workExecutionBindingSchema);
+var workReservationActivityPageSchema = workPageSchema(workReservationActivitySchema);
+var envelope6 = { version: z7.literal(workCommandVersion), commandId: z7.string().min(1).max(200), teamId: id7 };
+var issueTarget5 = z7.strictObject({ kind: z7.literal("issue"), id: id7 });
+var workReservationCommandSchema = z7.discriminatedUnion("type", [
+  /** Records one exact legacy reference for an Issue (Team admin). */
+  z7.strictObject({
+    ...envelope6,
+    type: z7.literal("legacy_alias.record"),
+    target: issueTarget5,
+    payload: z7.strictObject({ alias: id7 })
+  })
+]);
+var workReservationCommandTypes = workReservationCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkReservationCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workReservationCommandTypes.includes(type);
+}
+var workReservationCommandResultSchema = z7.object({
+  commandId: id7,
+  type: z7.string(),
+  teamId: id7,
+  status: z7.enum(["accepted", "completed"]),
+  replayed: z7.boolean(),
+  recordedAt: timestamp6,
+  activityId: id7,
+  outcome: z7.discriminatedUnion("kind", [
+    z7.object({ kind: z7.literal("reservation"), reservation: workExecutionReservationSchema }),
+    z7.object({ kind: z7.literal("binding"), binding: workExecutionBindingSchema, reservation: workExecutionReservationSchema }),
+    z7.object({ kind: z7.literal("legacy_alias"), alias: workLegacyAliasSchema })
+  ])
+});
+var workReservationErrorCodes = [
+  "issue_run_live",
+  "stale_generation",
+  "scope_revision_conflict",
+  "agent_ineligible",
+  "execution_held",
+  "attention_open",
+  "agent_start_not_allowed",
+  "stale_run_active",
+  "alias_conflict",
+  "issue_occupied"
+];
+
+// src/work-discussion.ts
+import { z as z8 } from "zod";
+var id8 = z8.string().min(1).max(160);
+var timestamp7 = z8.iso.datetime();
+var version6 = z8.number().int().positive();
+var sequence = z8.number().int().positive();
+var workCommentBodySchema = z8.string().trim().min(1).max(1e5);
+var reason2 = z8.string().trim().max(2e3).nullable().default(null);
+var url2 = z8.url({ protocol: /^https?$/ }).max(2e3).refine((value) => {
+  const parsed = new URL(value);
+  return parsed.username === "" && parsed.password === "";
+}, "credentials are not allowed in a link");
+var workLinkUrlSchema = url2;
+var workThreadOwnerSchema = z8.object({ kind: z8.enum(["issue", "plan"]), id: id8 });
+var workThreadSchema = z8.object({ threadId: id8, teamId: id8, owner: workThreadOwnerSchema, boundAt: timestamp7 });
+var workDiscussionTombstoneSchema = z8.object({ by: workActorSchema, at: timestamp7, commandId: id8, reason: z8.string().nullable() });
+var workCommentEditSchema = z8.object({ by: workActorSchema, at: timestamp7, commandId: id8 });
+var workCommentSchema = z8.object({
+  id: id8,
+  teamId: id8,
+  threadId: id8,
+  owner: workThreadOwnerSchema,
+  /** The comment this one replies to, in the same Thread; null for a top-level comment. */
+  parentId: id8.nullable(),
+  /** The current Markdown text; null once the comment is deleted (the tombstone stays readable). */
+  body: z8.string().nullable(),
+  /**
+   * The original author: `human` (a member), `agent` (a Run) or `external` (a source principal); or, for an imported
+   * comment whose source author was not captured, `{kind: "system", component: "import"}` (DRI-307). Decoders (the
+   * CLI and macOS consumers of DRI-342) must accept `system` here.
+   */
+  author: workActorSchema,
+  /** Who recorded it: the member who posted or imported it, or an in-Hub component. */
+  recordedBy: workActorSchema,
+  sourceReferenceId: id8.nullable(),
+  /** The current revision of its text, from 1. */
+  revision: sequence,
+  edited: workCommentEditSchema.nullable(),
+  deletion: workDiscussionTombstoneSchema.nullable(),
+  version: version6,
+  createdAt: timestamp7,
+  updatedAt: timestamp7
+});
+var workCommentRevisionSchema = z8.object({
+  commentId: id8,
+  revision: sequence,
+  body: z8.string().nullable(),
+  recordedBy: workActorSchema,
+  at: timestamp7,
+  commandId: id8
 });
+var workAttachmentAvailabilitySchema = z8.enum(["unknown", "available", "unavailable"]);
+var workAttachmentCheckSchema = z8.object({
+  id: id8,
+  attachmentId: id8,
+  availability: z8.enum(["available", "unavailable"]),
+  httpStatus: z8.number().int().nullable(),
+  detail: z8.string().nullable(),
+  checkedBy: workActorSchema,
+  checkedAt: timestamp7,
+  commandId: id8
+});
+var workAttachmentSchema = z8.object({
+  id: id8,
+  teamId: id8,
+  threadId: id8,
+  owner: workThreadOwnerSchema,
+  /** The comment it belongs to, or null when it belongs to the Thread's Issue or Plan. */
+  commentId: id8.nullable(),
+  url: z8.string(),
+  title: z8.string(),
+  mediaType: z8.string().nullable(),
+  sizeBytes: z8.number().int().nullable(),
+  /** The latest check's verdict (`unknown` before any), with that check's ID and time. */
+  availability: z8.object({ state: workAttachmentAvailabilitySchema, checkId: id8.nullable(), checkedAt: timestamp7.nullable() }),
+  /** As a comment's: `human`, `external`, or `system` (`import`) for an imported link with no captured author (DRI-307). */
+  author: workActorSchema,
+  recordedBy: workActorSchema,
+  sourceReferenceId: id8.nullable(),
+  removal: workDiscussionTombstoneSchema.nullable(),
+  version: version6,
+  createdAt: timestamp7,
+  updatedAt: timestamp7
+});
+var workTranscriptLinkSchema = z8.object({
+  id: id8,
+  teamId: id8,
+  threadId: id8,
+  owner: workThreadOwnerSchema,
+  access: z8.enum(["visible", "restricted"]),
+  run: z8.object({ runId: id8, attemptId: id8.nullable() }).nullable(),
+  /** Inclusive history sequence range; `throughSeq` null follows the Run's history as it grows. */
+  range: z8.object({ fromSeq: sequence, throughSeq: sequence.nullable() }).nullable(),
+  label: z8.string().nullable(),
+  linkedBy: workActorSchema,
+  linkedAt: timestamp7
+});
+var workTranscriptHistorySchema = z8.object({
+  linkId: id8,
+  runId: id8,
+  range: z8.object({ fromSeq: sequence, throughSeq: sequence.nullable() }),
+  /** The last sequence of the range the Run has recorded so far. */
+  through: z8.number().int().nonnegative(),
+  archives: z8.array(z8.object({ id: id8, checksum: z8.string(), firstSeq: sequence, lastSeq: sequence })),
+  batches: z8.array(z8.object({ firstSeq: sequence, records: z8.array(z8.unknown()) }))
+});
+var workDiscussionActivityKindSchema = z8.enum([
+  "comment.added",
+  "comment.edited",
+  "comment.deleted",
+  "attachment.linked",
+  "attachment.checked",
+  "attachment.removed",
+  "transcript.linked"
+]);
+var workDiscussionActivitySchema = workActivitySchema.extend({
+  subject: z8.object({ kind: z8.enum(["comment", "attachment", "transcript_link"]), id: id8 }),
+  kind: workDiscussionActivityKindSchema
+});
+var workCommentPageSchema = workPageSchema(workCommentSchema);
+var workCommentRevisionPageSchema = workPageSchema(workCommentRevisionSchema);
+var workAttachmentPageSchema = workPageSchema(workAttachmentSchema);
+var workAttachmentCheckPageSchema = workPageSchema(workAttachmentCheckSchema);
+var workTranscriptLinkPageSchema = workPageSchema(workTranscriptLinkSchema);
+var workDiscussionActivityPageSchema = workPageSchema(workDiscussionActivitySchema);
+var envelope7 = { version: z8.literal(workCommandVersion), commandId: z8.string().min(1).max(200), teamId: id8 };
+var threadTarget = z8.strictObject({ kind: z8.literal("thread"), id: id8 });
+var commentTarget = z8.strictObject({ kind: z8.literal("comment"), id: id8 });
+var attachmentTarget = z8.strictObject({ kind: z8.literal("attachment"), id: id8 });
+var otherAuthor = z8.discriminatedUnion("kind", [
+  z8.strictObject({ kind: z8.literal("external"), principalId: id8 }),
+  z8.strictObject({ kind: z8.literal("agent"), runId: id8 })
+]);
+var workDiscussionCommandSchema = z8.discriminatedUnion("type", [
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("comment.add"),
+    target: threadTarget,
+    payload: z8.strictObject({
+      body: workCommentBodySchema,
+      parentId: id8.nullable().default(null),
+      author: otherAuthor.nullable().default(null),
+      sourceReferenceId: id8.nullable().default(null)
+    })
+  }),
+  /** Replaces the text at the comment's version, recording the next revision. */
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("comment.edit"),
+    target: commentTarget,
+    expectedVersion: version6,
+    payload: z8.strictObject({ body: workCommentBodySchema })
+  }),
+  /** A soft delete: an attributed tombstone; replies, attachments and history stay. */
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("comment.delete"),
+    target: commentTarget,
+    expectedVersion: version6,
+    payload: z8.strictObject({ reason: reason2 })
+  }),
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("attachment.link"),
+    target: threadTarget,
+    payload: z8.strictObject({
+      url: url2,
+      title: z8.string().trim().min(1).max(500),
+      mediaType: z8.string().regex(/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i).max(200).nullable().default(null),
+      sizeBytes: z8.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable().default(null),
+      commentId: id8.nullable().default(null),
+      author: z8.strictObject({ kind: z8.literal("external"), principalId: id8 }).nullable().default(null),
+      sourceReferenceId: id8.nullable().default(null)
+    })
+  }),
+  /** Records one availability observation; every check is kept, the latest is the attachment's state. */
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("attachment.check"),
+    target: attachmentTarget,
+    expectedVersion: version6,
+    payload: z8.strictObject({
+      availability: z8.enum(["available", "unavailable"]),
+      httpStatus: z8.number().int().min(100).max(599).nullable().default(null),
+      detail: reason2
+    })
+  }),
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("attachment.remove"),
+    target: attachmentTarget,
+    expectedVersion: version6,
+    payload: z8.strictObject({ reason: reason2 })
+  }),
+  /**
+   * Links a range of a Run's history; the caller must be able to see the Run. The Hub records the Run's current
+   * attempt; a given `attemptId` must be that attempt (`invalid_request` otherwise).
+   */
+  z8.strictObject({
+    ...envelope7,
+    type: z8.literal("transcript.link"),
+    target: threadTarget,
+    payload: z8.strictObject({
+      runId: id8,
+      attemptId: id8.nullable().default(null),
+      range: z8.strictObject({ fromSeq: sequence.default(1), throughSeq: sequence.nullable().default(null) }).default({ fromSeq: 1, throughSeq: null }),
+      label: z8.string().trim().max(500).nullable().default(null)
+    })
+  })
+]);
+var workDiscussionCommandTypes = workDiscussionCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkDiscussionCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workDiscussionCommandTypes.includes(type);
+}
+var workDiscussionCommandResultSchema = z8.object({
+  commandId: id8,
+  type: z8.string(),
+  teamId: id8,
+  status: z8.enum(["accepted", "completed"]),
+  replayed: z8.boolean(),
+  recordedAt: timestamp7,
+  activityId: id8,
+  outcome: z8.discriminatedUnion("kind", [
+    z8.object({ kind: z8.literal("comment"), comment: workCommentSchema }),
+    z8.object({ kind: z8.literal("attachment"), attachment: workAttachmentSchema }),
+    z8.object({ kind: z8.literal("transcript_link"), link: workTranscriptLinkSchema })
+  ])
+});
+var workDiscussionErrorCodes = [
+  "run_not_team_visible",
+  "transcript_already_linked",
+  "source_key_conflict",
+  "source_kind_mismatch",
+  "source_target_mismatch"
+];
+
+// src/work-lifecycle.ts
+import { z as z9 } from "zod";
+var id9 = z9.string().min(1).max(160);
+var workLifecycleEventKindSchema = z9.enum([
+  "completed",
+  "canceled",
+  "reopened",
+  "archived",
+  "unarchived",
+  "deleted",
+  "restored"
+]);
+var workLifecycleEventSchema = z9.object({
+  seq: z9.number().int().positive(),
+  teamId: id9,
+  subject: z9.object({ kind: z9.enum(["issue", "plan"]), id: id9 }),
+  event: workLifecycleEventKindSchema,
+  from: z9.string(),
+  to: z9.string(),
+  /**
+   * `requested` on a cancellation: the Issue's cancellation asks Coordination to cancel its execution. It is a
+   * request only, never proof that compute stopped or that a reservation was released (root ADR-0017).
+   */
+  executionCancel: z9.enum(["requested"]).nullable(),
+  /** The attributed Activity that made the change: actor, command, time and `{from, to}` changes. */
+  activity: workActivitySchema
+});
+var workLifecycleEventPageSchema = workPageSchema(workLifecycleEventSchema);
+var workSourceKeyLifecycleSchema = z9.object({
+  key: workSourceKeySchema,
+  referenceId: id9.nullable(),
+  target: workSourceTargetSchema.nullable(),
+  lifecycle: workLifecycleSchema.nullable(),
+  tombstoned: z9.boolean()
+});
+
+// src/work-imports.ts
+import { z as z10 } from "zod";
+var id10 = z10.string().min(1).max(160);
+var timestamp8 = z10.iso.datetime();
+var sourceTimestamp2 = z10.iso.datetime({ offset: true });
+var version7 = z10.number().int().nonnegative();
+var token2 = z10.string().min(1).max(200).regex(/^\S(?:.*\S)?$/, "no surrounding whitespace");
+var externalId2 = z10.string().min(1).max(500);
+var readable2 = z10.string().trim().min(1).max(500);
+var reason3 = z10.string().trim().min(1).max(2e3);
+var markdown2 = z10.string().max(1e5);
+var url3 = z10.url({ protocol: /^https?$/ }).max(2e3);
+var title2 = z10.string().trim().min(1).max(500);
+var workImportFormat = "drisp.normalized-import";
+var workImportFormatVersion = 1;
+var workImportKeySchema = z10.strictObject({ idNamespace: token2, externalId: externalId2 });
+var workImportFieldStates = ["value", "empty", "omitted", "unavailable", "unknown"];
+function workImportField(value) {
+  return z10.discriminatedUnion("state", [
+    z10.strictObject({ state: z10.literal("value"), value }),
+    z10.strictObject({ state: z10.literal("empty") }),
+    z10.strictObject({ state: z10.literal("omitted"), reason: reason3 }),
+    z10.strictObject({ state: z10.literal("unavailable"), reason: reason3 }),
+    z10.strictObject({ state: z10.literal("unknown") })
+  ]).default({ state: "unknown" });
+}
+var field = workImportField;
+var workImportCollections = [
+  "issues",
+  "containers",
+  "statuses",
+  "principals",
+  "labels",
+  "groups",
+  "comments",
+  "attachments",
+  "relations"
+];
+var workImportCollectionSchema = z10.enum(workImportCollections);
+var workImportCollectionStateSchema = z10.strictObject({
+  state: z10.enum(["complete", "empty", "partial", "omitted", "unavailable", "unknown"]),
+  reason: reason3.nullable().default(null)
+});
+var collectionDefault = { state: "unknown", reason: null };
+var workImportContainerSchema = z10.strictObject({
+  key: workImportKeySchema,
+  kind: token2,
+  name: readable2,
+  url: field(url3)
+});
+var workImportStatusSchema = z10.strictObject({
+  key: workImportKeySchema,
+  name: z10.string().trim().min(1).max(100),
+  category: workDeliveryStatusCategorySchema,
+  position: z10.number().int().nonnegative(),
+  /**
+   * `needs_human`: the source uses this status to ask a person for something ("Needs Human", "Needs Input"). It has
+   * no delivery meaning of its own: the mapping must name the delivery status an Issue keeps and an attention request.
+   */
+  semantics: z10.enum(["needs_human"]).nullable().default(null)
+});
+var workImportPrincipalSchema = z10.strictObject({
+  key: workImportKeySchema,
+  kind: z10.enum(["person", "bot", "unknown"]).default("unknown"),
+  displayName: field(readable2)
+});
+var workImportLabelSchema = z10.strictObject({
+  /** DRI-295's label name and color rules, so a label the preview would create is one the commit can create. */
+  key: workImportKeySchema,
+  name: workLabelNameSchema,
+  color: field(workLabelColorSchema),
+  /** The source group the label belongs to, if any. Drisp labels are flat: the group is reported, not imported. */
+  group: workImportKeySchema.nullable().default(null)
+});
+var workImportGroupSchema = z10.strictObject({
+  key: workImportKeySchema,
+  kind: token2,
+  of: z10.enum(["labels", "principals"]),
+  name: readable2,
+  members: z10.array(workImportKeySchema).max(1e3).default([])
+});
+var workImportIssueSchema = z10.strictObject({
+  key: workImportKeySchema,
+  title: title2,
+  identifier: field(readable2),
+  url: field(url3),
+  description: field(markdown2),
+  priority: field(workPrioritySchema),
+  /** A status of the envelope's catalog. */
+  status: field(workImportKeySchema),
+  /** Every container the source record sat in; one may be the import's Plan, the rest stay provenance. */
+  containers: field(z10.array(workImportKeySchema).max(20)),
+  creator: field(workImportKeySchema),
+  assignees: field(z10.array(workImportKeySchema).max(50)),
+  labels: field(z10.array(workImportKeySchema).max(100)),
+  sourceCreatedAt: field(sourceTimestamp2),
+  sourceUpdatedAt: field(sourceTimestamp2)
+});
+var workImportRelationSchema = z10.strictObject({
+  kind: z10.enum(["parent", "blocks", "duplicates", "related"]),
+  from: workImportKeySchema,
+  to: workImportKeySchema
+});
+var workImportCommentSchema = z10.strictObject({
+  key: workImportKeySchema,
+  issue: workImportKeySchema,
+  parent: workImportKeySchema.nullable().default(null),
+  author: field(workImportKeySchema),
+  /** DRI-303's comment body (trimmed, non-empty); a body that is empty or was not captured is a field state, not a comment. */
+  body: field(workCommentBodySchema),
+  sourceCreatedAt: field(sourceTimestamp2)
+});
+var workImportAttachmentSchema = z10.strictObject({
+  /** DRI-303's link rule: http or https, no embedded credentials. */
+  key: workImportKeySchema,
+  issue: workImportKeySchema,
+  title: field(readable2),
+  url: workLinkUrlSchema,
+  availability: z10.enum(["available", "unavailable", "unknown"]).default("unknown"),
+  author: field(workImportKeySchema),
+  sourceCreatedAt: field(sourceTimestamp2),
+  /**
+   * DRI-307: the comment that owns the link, when the source attached it to a comment rather than to the Issue. Left
+   * out (not null) when the link belongs to the Issue, so an envelope without it keeps its canonical form and digest.
+   */
+  comment: workImportKeySchema.optional()
+});
+var workImportLimitSchema = z10.strictObject({
+  collection: workImportCollectionSchema,
+  scope: z10.enum(["envelope", "per_issue"]),
+  limit: z10.number().int().positive(),
+  observed: z10.number().int().nonnegative().nullable().default(null),
+  reason: reason3.nullable().default(null)
+});
+var workImportUnsupportedSchema = z10.strictObject({
+  semantics: token2,
+  description: reason3,
+  subjects: z10.array(z10.strictObject({ collection: workImportCollectionSchema, key: workImportKeySchema })).max(1e3).default([])
+});
+var workImportCompletenessSchema = z10.strictObject({
+  collections: z10.strictObject(Object.fromEntries(workImportCollections.map((c) => [c, workImportCollectionStateSchema.default(collectionDefault)]))),
+  limits: z10.array(workImportLimitSchema).max(100).default([]),
+  unsupported: z10.array(workImportUnsupportedSchema).max(200).default([])
+});
+var workImportEnvelopeSchema = z10.strictObject({
+  format: z10.literal(workImportFormat),
+  formatVersion: z10.literal(workImportFormatVersion),
+  adapter: z10.strictObject({ name: token2, version: z10.string().trim().min(1).max(100) }),
+  capturedAt: sourceTimestamp2,
+  /** The one source space every record belongs to; compared exactly with DRI-302's source spaces. */
+  source: z10.strictObject({ provider: token2, instance: token2, workspaceId: externalId2, displayName: readable2.nullable().default(null) }),
+  containers: z10.array(workImportContainerSchema).default([]),
+  statuses: z10.array(workImportStatusSchema).default([]),
+  principals: z10.array(workImportPrincipalSchema).default([]),
+  labels: z10.array(workImportLabelSchema).default([]),
+  groups: z10.array(workImportGroupSchema).default([]),
+  issues: z10.array(workImportIssueSchema).default([]),
+  relations: z10.array(workImportRelationSchema).default([]),
+  comments: z10.array(workImportCommentSchema).default([]),
+  attachments: z10.array(workImportAttachmentSchema).default([]),
+  completeness: workImportCompletenessSchema
+});
+var workImportLimits = {
+  issues: 500,
+  containers: 100,
+  statuses: 100,
+  principals: 500,
+  labels: 500,
+  groups: 100,
+  comments: 2e3,
+  attachments: 1e3,
+  relations: 2e3
+};
+var workImportBodyLimit = 1536 * 1024;
+var statusEntry = z10.strictObject({ source: workImportKeySchema, statusId: workDeliverySlugSchema });
+var needsHumanEntry = z10.strictObject({
+  source: workImportKeySchema,
+  statusId: workDeliverySlugSchema,
+  /** The request's message; when absent the commit derives one naming the source status. */
+  attention: z10.strictObject({ reason: workManualAttentionReasonSchema, message: z10.string().trim().min(1).max(1e4).nullable().default(null) })
+});
+var workImportMappingSchema = z10.strictObject({
+  expectedWorkflow: z10.strictObject({ workflowId: id10, revision: z10.number().int().positive() }),
+  statuses: z10.discriminatedUnion("mode", [
+    z10.strictObject({
+      mode: z10.literal("map"),
+      statuses: z10.array(statusEntry).max(100).default([]),
+      needsHuman: z10.array(needsHumanEntry).max(100).default([])
+    }),
+    z10.strictObject({
+      mode: z10.literal("adopt"),
+      name: title2,
+      statuses: z10.array(statusEntry).min(1).max(100),
+      initialStatus: workImportKeySchema,
+      needsHuman: z10.array(needsHumanEntry).max(100).default([])
+    })
+  ]),
+  principals: z10.array(z10.strictObject({ source: workImportKeySchema, memberId: id10 })).max(500).default([]),
+  labels: z10.array(z10.discriminatedUnion("kind", [
+    z10.strictObject({ source: workImportKeySchema, kind: z10.literal("existing"), labelId: id10 }),
+    z10.strictObject({ source: workImportKeySchema, kind: z10.literal("create"), name: workLabelNameSchema })
+  ])).max(500).default([]),
+  plan: z10.strictObject({
+    target: z10.discriminatedUnion("kind", [
+      z10.strictObject({ kind: z10.literal("existing"), planId: id10 }),
+      z10.strictObject({ kind: z10.literal("create"), title: title2, description: markdown2.default("") })
+    ]),
+    /** Only Issues observed in this container join the Plan; null means every created Issue does. */
+    container: workImportKeySchema.nullable().default(null)
+  }).nullable().default(null)
+});
+var workImportCommandSchema = z10.discriminatedUnion("type", [
+  z10.strictObject({
+    version: z10.literal(workCommandVersion),
+    commandId: z10.string().min(1).max(200),
+    teamId: id10,
+    type: z10.literal("import.preview"),
+    payload: z10.strictObject({ envelope: workImportEnvelopeSchema, mapping: workImportMappingSchema })
+  }),
+  // ── Import commit (DRI-306) ──
+  /**
+   * Commits a previewed batch, on the same route, authority (Team admin), envelope and receipts as the preview. The
+   * Hub rechecks the batch against the Team as it is now, inside the commit's transaction, and refuses it with
+   * `import_preview_stale` (or `import_batch_blocked`) and the blocking findings when anything changed.
+   */
+  z10.strictObject({
+    version: z10.literal(workCommandVersion),
+    commandId: z10.string().min(1).max(200),
+    teamId: id10,
+    type: z10.literal("import.commit"),
+    payload: z10.strictObject({ batchId: id10 })
+  }),
+  // ── end DRI-306 ──
+  // ── Import completion (DRI-307) ──
+  /**
+   * Completes the discussion components (comments, replies and link-only attachments) a committed batch left pending,
+   * on the same route, authority (Team admin), envelope and receipts. `components` narrows the attempt to some of
+   * them; null attempts every component still pending (or failed by an earlier completion). Already completed,
+   * skipped, omitted and commit-time failed components keep their outcome.
+   */
+  z10.strictObject({
+    version: z10.literal(workCommandVersion),
+    commandId: z10.string().min(1).max(200),
+    teamId: id10,
+    type: z10.literal("import.complete"),
+    payload: z10.strictObject({
+      batchId: id10,
+      components: z10.array(z10.strictObject({ collection: z10.enum(["comments", "attachments"]), key: workImportKeySchema })).min(1).max(500).nullable().default(null)
+    })
+  })
+  // ── end DRI-307 ──
+]);
+var workImportCommandTypes = workImportCommandSchema.options.map((option) => option.shape.type.value);
+function isWorkImportCommand(body) {
+  const type = body?.type;
+  return typeof type === "string" && workImportCommandTypes.includes(type);
+}
+var workImportDispositions = [
+  "create",
+  "already_bound",
+  "map",
+  "external",
+  "preserved",
+  "unresolved",
+  "omitted",
+  "conflict"
+];
+var workImportFindingSchema = z10.object({
+  code: z10.string(),
+  severity: z10.enum(["blocking", "notice"]),
+  detail: z10.record(z10.string(), z10.json()).default({})
+});
+var workImportTargetSchema = z10.object({
+  kind: z10.enum(["issue", "plan", "member", "label", "status", "source_reference"]),
+  id: id10
+});
+var workImportItemSchema = z10.object({
+  seq: z10.number().int().positive(),
+  batchId: id10,
+  collection: workImportCollectionSchema,
+  /** The source record's key; a relation's is `from`, with both endpoints in `proposed`. */
+  key: z10.object({ idNamespace: z10.string(), externalId: z10.string() }),
+  disposition: z10.enum(workImportDispositions),
+  target: workImportTargetSchema.nullable(),
+  /** What the commit would write, for review: resolved status, Plan, parent, assignees, labels, attention. */
+  proposed: z10.record(z10.string(), z10.json()).nullable(),
+  findings: z10.array(workImportFindingSchema)
+});
+var collectionSummary = z10.object({ state: z10.string(), reason: z10.string().nullable(), count: z10.number().int().nonnegative() });
+var workImportCompletenessSummarySchema = z10.object({
+  collections: z10.record(z10.string(), collectionSummary),
+  /** Per collection and field, how many records had it `empty`, `omitted`, `unavailable` or `unknown`. */
+  fields: z10.array(z10.object({ collection: z10.string(), field: z10.string(), state: z10.string(), count: z10.number().int().positive() })),
+  limits: z10.array(z10.object({
+    collection: z10.string(),
+    scope: z10.string(),
+    limit: z10.number().int(),
+    observed: z10.number().int().nullable(),
+    reason: z10.string().nullable()
+  })),
+  unsupported: z10.array(z10.object({
+    semantics: z10.string(),
+    description: z10.string(),
+    subjects: z10.array(z10.object({ collection: z10.string(), key: z10.object({ idNamespace: z10.string(), externalId: z10.string() }) }))
+  }))
+});
+var workImportCommitSchema = z10.object({
+  commandId: id10,
+  committedBy: workActorSchema,
+  committedAt: timestamp8,
+  activityId: id10,
+  /** Outcome counts over every outcome row (records and components). */
+  counts: z10.record(z10.string(), z10.number().int().nonnegative())
+});
+var workImportBatchSchema = z10.object({
+  id: id10,
+  teamId: id10,
+  /** `ready` when no finding blocks the commit; `blocked` otherwise; `committed` once the commit (DRI-306) wrote it. */
+  state: z10.enum(["ready", "blocked", "committed"]),
+  format: z10.string(),
+  formatVersion: z10.number().int().positive(),
+  adapter: z10.object({ name: z10.string(), version: z10.string() }),
+  capturedAt: z10.string(),
+  source: z10.object({ provider: z10.string(), instance: z10.string(), workspaceId: z10.string(), displayName: z10.string().nullable() }),
+  /** DRI-302's registered space for that key, or null when the commit would register it. */
+  spaceId: id10.nullable(),
+  /** sha256 of the canonical envelope, and of the canonical mapping; both frozen with the batch. */
+  snapshotDigest: z10.string().regex(/^[0-9a-f]{64}$/),
+  mappingDigest: z10.string().regex(/^[0-9a-f]{64}$/),
+  expectedWorkflow: z10.object({ workflowId: id10, revision: z10.number().int().positive() }),
+  statusMode: z10.enum(["map", "adopt"]),
+  /**
+   * For `adopt`: the admin workflow commands the commit would run, previewed and not executed: `workflow.create` with
+   * this manual-only definition, then `workflow.activate` with an empty migration (the Team has no Issues).
+   */
+  proposedWorkflow: z10.object({ definition: workDeliveryWorkflowDefinitionSchema, commands: z10.array(z10.string()) }).nullable(),
+  plan: z10.object({
+    kind: z10.enum(["existing", "create"]),
+    planId: id10.nullable(),
+    title: z10.string().nullable(),
+    container: z10.object({ idNamespace: z10.string(), externalId: z10.string() }).nullable()
+  }).nullable(),
+  counts: z10.object({
+    items: z10.number().int().nonnegative(),
+    blocking: z10.number().int().nonnegative(),
+    dispositions: z10.record(z10.string(), z10.number().int().nonnegative())
+  }),
+  /** Findings about the batch as a whole (adoption into a non-empty Team, an unknown Plan, an unregistered space). */
+  findings: z10.array(workImportFindingSchema),
+  completeness: workImportCompletenessSummarySchema,
+  limits: z10.record(z10.string(), z10.number().int().positive()),
+  initiator: workActorSchema,
+  commandId: id10,
+  version: version7,
+  createdAt: timestamp8,
+  /** The commit (DRI-306), once there is one: who, when, under which command, and its outcome counts. */
+  commit: workImportCommitSchema.nullable().default(null),
+  /** DRI-307: the latest completion of its discussion components, once there is one. */
+  completion: z10.lazy(() => workImportCompletionSchema).nullable().default(null)
+});
+var workImportOutcomes = ["created", "mapped", "skipped_existing", "pending", "omitted", "failed"];
+var workImportOutcomeSchema = z10.object({
+  seq: z10.number().int().positive(),
+  batchId: id10,
+  /** The previewed item this outcome belongs to. */
+  itemSeq: z10.number().int().positive(),
+  collection: workImportCollectionSchema,
+  key: z10.object({ idNamespace: z10.string(), externalId: z10.string() }),
+  /** `record` for the source record itself; otherwise the part (`source_reference`, `assignee`, `label`, `parent`, …). */
+  component: z10.string(),
+  outcome: z10.enum(workImportOutcomes),
+  /** The record written or resolved: `{kind, id}` (`issue`, `plan`, `label`, `member`, `comment`, `attention`, …). */
+  target: z10.object({ kind: z10.string(), id: id10 }).nullable(),
+  code: z10.string().nullable(),
+  detail: z10.record(z10.string(), z10.json())
+});
+var workImportOutcomePageSchema = workPageSchema(workImportOutcomeSchema);
+var workImportComponentStates = [
+  "pending",
+  "completed",
+  "failed",
+  "omitted",
+  "skipped_existing",
+  "skipped_local_edit",
+  "skipped_tombstoned"
+];
+var workImportComponentSchema = z10.object({
+  seq: z10.number().int().positive(),
+  batchId: id10,
+  itemSeq: z10.number().int().positive(),
+  collection: z10.enum(["comments", "attachments"]),
+  key: z10.object({ idNamespace: z10.string(), externalId: z10.string() }),
+  state: z10.enum(workImportComponentStates),
+  code: z10.string().nullable(),
+  target: z10.object({ kind: z10.string(), id: id10 }).nullable(),
+  detail: z10.record(z10.string(), z10.json()),
+  /** `commit` while the state is the commit's; `completion` once a completion attempted it. */
+  origin: z10.enum(["commit", "completion"]),
+  /** How many completions attempted it, and the last one's command ID. */
+  attempts: z10.number().int().nonnegative(),
+  lastCommandId: z10.string().nullable(),
+  updatedAt: timestamp8
+});
+var workImportComponentPageSchema = workPageSchema(workImportComponentSchema);
+var workImportCompletenessNoteSchema = z10.object({
+  collection: z10.string(),
+  state: z10.string(),
+  reason: z10.string().nullable(),
+  limits: z10.array(z10.object({ scope: z10.string(), limit: z10.number().int(), observed: z10.number().int().nullable(), reason: z10.string().nullable() }))
+});
+var workImportCompletionSchema = z10.object({
+  commandId: id10,
+  completedBy: workActorSchema,
+  completedAt: timestamp8,
+  activityId: id10,
+  /** Components this completion attempted, and their resulting states. */
+  attempted: z10.number().int().nonnegative(),
+  counts: z10.record(z10.string(), z10.number().int().nonnegative()),
+  /** Every discussion component of the batch by state, after this completion. */
+  totals: z10.record(z10.string(), z10.number().int().nonnegative()),
+  /** Never an implied "all imported": each discussion collection the source did not capture completely. */
+  completeness: z10.array(workImportCompletenessNoteSchema)
+});
+var workImportSnapshotSchema = z10.object({
+  batchId: id10,
+  snapshotDigest: z10.string(),
+  mappingDigest: z10.string(),
+  envelope: z10.record(z10.string(), z10.json()),
+  mapping: z10.record(z10.string(), z10.json())
+});
+var workImportBatchPageSchema = workPageSchema(workImportBatchSchema);
+var workImportItemPageSchema = workPageSchema(workImportItemSchema);
+var workImportCommandResultSchema = z10.object({
+  commandId: id10,
+  type: z10.string(),
+  teamId: id10,
+  status: z10.enum(["accepted", "completed"]),
+  replayed: z10.boolean(),
+  recordedAt: timestamp8,
+  activityId: id10,
+  outcome: z10.discriminatedUnion("kind", [
+    z10.object({ kind: z10.literal("import_batch"), batch: workImportBatchSchema }),
+    /**
+     * The commit (DRI-306): the committed batch. `alreadyCommitted` when another command had committed it first: no
+     * record was written and the batch's durable outcome is returned. Outcomes are read by page.
+     */
+    z10.object({ kind: z10.literal("import_commit"), batch: workImportBatchSchema, alreadyCommitted: z10.boolean() }),
+    /** The completion (DRI-307): the batch with this completion as its latest. Components are read by page. */
+    z10.object({ kind: z10.literal("import_completion"), batch: workImportBatchSchema, completion: workImportCompletionSchema })
+  ])
+});
+var workImportErrorCodes = [
+  "invalid_import_envelope",
+  "invalid_import_mapping",
+  "import_limit_exceeded",
+  "workflow_revision_conflict",
+  /**
+   * DRI-306. `import_preview_stale`: the Team changed since a `ready` preview so that the commit would now refuse it;
+   * `import_batch_blocked`: the preview itself was `blocked`. Both carry `findings` (each with `collection` and `key`,
+   * or neither for a batch finding, `code`, `severity: "blocking"` and `detail`) and `count`; nothing is recorded.
+   */
+  "import_preview_stale",
+  "import_batch_blocked",
+  /**
+   * DRI-307. `import_batch_not_committed`: a completion of a batch that was never committed. `import_component_unknown`:
+   * a named component is not a comment or attachment of the batch (carries `collection` and `key`).
+   */
+  "import_batch_not_committed",
+  "import_component_unknown"
+];
+
+// src/work-deployments.ts
+import { z as z11 } from "zod";
+var id11 = z11.string().min(1).max(160);
+var timestamp9 = z11.iso.datetime();
+var version8 = z11.number().int().positive();
+var slug2 = z11.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+var workDeploymentPurposeSchema = z11.enum(["verification", "production"]);
+var workDeploymentLifecycleSchema = z11.enum(["active", "replaced", "retired"]);
+var workDeploymentSchema = z11.object({
+  id: id11,
+  teamId: id11,
+  issueId: id11,
+  /** Per Issue, from 1, in recording order. */
+  number: z11.number().int().positive(),
+  /** The candidate this deployment deploys. */
+  candidateId: id11,
+  environment: slug2,
+  purpose: workDeploymentPurposeSchema,
+  /** The deployment or release identity in that environment (a deploy ID, a release tag). */
+  ref: z11.string(),
+  url: z11.string().nullable(),
+  lifecycle: workDeploymentLifecycleSchema,
+  /** The deployment this one replaced in its environment, and the one that replaced it. */
+  replaces: id11.nullable(),
+  replacedBy: id11.nullable(),
+  retirement: workEvidenceDecisionSchema.nullable(),
+  runId: id11.nullable(),
+  recordedBy: workActorSchema,
+  occurredAt: timestamp9,
+  recordedAt: timestamp9,
+  commandId: id11,
+  /** The deployment's own concurrency version: replacement and retirement bump it. */
+  version: version8
+});
+var workVerificationOutcomeSchema = z11.enum(["pending", "passed", "failed"]);
+var workVerificationStandingSchema = z11.enum([
+  "current",
+  "superseded",
+  "stale_deployment",
+  "stale_candidate",
+  "stale_scope_revision"
+]);
+var workVerificationAttemptSchema = z11.object({
+  id: id11,
+  teamId: id11,
+  issueId: id11,
+  /** Per deployment, from 1. */
+  number: z11.number().int().positive(),
+  /** The evaluated inputs: the scope revision, the candidate and the deployment of that candidate. */
+  inputs: z11.object({ scopeRevision: workScopeRevisionRefSchema, candidateId: id11, deploymentId: id11, environment: slug2, deploymentRef: z11.string() }),
+  outcome: workVerificationOutcomeSchema,
+  /** The QA evidence that decides the outcome, while it is live. */
+  outcomeEvidenceId: id11.nullable(),
+  runId: id11.nullable(),
+  supersedes: id11.nullable(),
+  supersededBy: id11.nullable(),
+  startedBy: workActorSchema,
+  occurredAt: timestamp9,
+  recordedAt: timestamp9,
+  commandId: id11,
+  version: version8,
+  standing: workVerificationStandingSchema
+});
+var workProductionTrailEntrySchema = z11.object({
+  confirmation: workEvidenceSchema,
+  verificationAttempt: workVerificationAttemptSchema.nullable(),
+  verificationDeployment: workDeploymentSchema.nullable(),
+  productionDeployment: workDeploymentSchema
+});
+var workDeploymentActivityKindSchema = z11.enum([
+  "deployment.recorded",
+  "deployment.replaced",
+  "deployment.retired",
+  "verification.started",
+  "verification.superseded",
+  "verification.concluded"
+]);
+var workDeploymentActivitySchema = workActivitySchema.extend({
+  subject: z11.object({ kind: z11.enum(["deployment", "verification_attempt"]), id: id11 }),
+  kind: workDeploymentActivityKindSchema
+});
+var workDeploymentPageSchema = workPageSchema(workDeploymentSchema);
+var workVerificationAttemptPageSchema = workPageSchema(workVerificationAttemptSchema);
+var workProductionTrailPageSchema = workPageSchema(workProductionTrailEntrySchema);
+var workDeploymentActivityPageSchema = workPageSchema(workDeploymentActivitySchema);
+var envelope8 = { version: z11.literal(workCommandVersion), commandId: z11.string().min(1).max(200), teamId: id11 };
+var issueTarget6 = z11.strictObject({ kind: z11.literal("issue"), id: id11 });
+var workDeploymentCommandSchema = z11.discriminatedUnion("type", [
+  /**
+   * Records a deployment of a candidate of the Issue's current scope revision. An active deployment of the Issue in
+   * the same environment is replaced by it; replacing a verified deployment of the current candidate holds automation.
+   */
+  z11.strictObject({
+    ...envelope8,
+    type: z11.literal("deployment.record"),
+    target: issueTarget6,
+    payload: z11.strictObject({
+      candidateId: id11,
+      environment: slug2,
+      purpose: workDeploymentPurposeSchema,
+      ref: z11.string().trim().min(1).max(200),
+      url: z11.url({ protocol: /^https?$/ }).max(2e3).nullable().default(null),
+      occurredAt: timestamp9,
+      runId: id11.nullable().default(null)
+    })
+  }),
+  /** Retires an active deployment at its version, with a reason. It stays in history and satisfies nothing. */
+  z11.strictObject({
+    ...envelope8,
+    type: z11.literal("deployment.retire"),
+    target: z11.strictObject({ kind: z11.literal("deployment"), id: id11 }),
+    expectedVersion: version8,
+    payload: z11.strictObject({ reason: z11.string().trim().min(1).max(2e3) })
+  }),
+  /**
+   * Starts a verification attempt on an active verification deployment. It becomes the deployment's current attempt
+   * and supersedes the one before; a QA result (`evidence.record` naming it) concludes it.
+   */
+  z11.strictObject({
+    ...envelope8,
+    type: z11.literal("verification.start"),
+    target: issueTarget6,
+    payload: z11.strictObject({ deploymentId: id11, occurredAt: timestamp9, runId: id11.nullable().default(null) })
+  })
+]);
+var workDeploymentCommandTypes = workDeploymentCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkDeploymentCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workDeploymentCommandTypes.includes(type);
+}
+var workDeploymentCommandResultSchema = z11.object({
+  commandId: id11,
+  type: z11.string(),
+  teamId: id11,
+  status: z11.enum(["accepted", "completed"]),
+  replayed: z11.boolean(),
+  recordedAt: timestamp9,
+  activityId: id11,
+  outcome: z11.discriminatedUnion("kind", [
+    /** `replaced` is the deployment this one replaced; `issue` is the Issue when the change held its automation. */
+    z11.object({
+      kind: z11.literal("deployment"),
+      deployment: workDeploymentSchema,
+      replaced: workDeploymentSchema.nullable(),
+      issue: workIssueSchema.nullable()
+    }),
+    /** `superseded` is the deployment's previous current attempt. */
+    z11.object({
+      kind: z11.literal("verification_attempt"),
+      attempt: workVerificationAttemptSchema,
+      superseded: workVerificationAttemptSchema.nullable()
+    })
+  ])
+});
+var workDeploymentErrorCodes = ["deployment_closed", "attempt_concluded", "not_verified", "not_current_candidate"];
+
+// src/work-relations.ts
+import { z as z12 } from "zod";
+var id12 = z12.string().min(1).max(160);
+var timestamp10 = z12.iso.datetime();
+var workIssueRelationKindSchema = z12.enum(["blocked_by", "duplicate_of", "related"]);
+var workRelationRemovalSchema = z12.object({ by: workActorSchema, at: timestamp10, commandId: id12, reason: z12.string().nullable() });
+var workIssueRelationSchema = z12.object({
+  id: id12,
+  teamId: id12,
+  kind: workIssueRelationKindSchema,
+  /** The dependent (`blocked_by`), the duplicate (`duplicate_of`), or the side that recorded a `related` link. */
+  issueId: id12,
+  /** The prerequisite (`blocked_by`), the canonical Issue (`duplicate_of`), or the other side of a `related` link. */
+  targetId: id12,
+  addedBy: workActorSchema,
+  addedAt: timestamp10,
+  commandId: id12,
+  removal: workRelationRemovalSchema.nullable()
+});
+var workRelationEndpointSchema = z12.object({
+  id: id12,
+  identifier: id12,
+  statusId: id12,
+  category: workDeliveryStatusCategorySchema,
+  lifecycle: workLifecycleSchema
+});
+var workDependencyReasonSchema = z12.enum(["not_completed", "canceled"]);
+var workDependencyRemedySchema = z12.enum(["complete_prerequisite", "repoint_to_canonical", "remove_relation"]);
+var workUnsatisfiedDependencySchema = z12.object({
+  relationId: id12,
+  blocker: workRelationEndpointSchema,
+  reason: workDependencyReasonSchema,
+  /** The prerequisite's canonical Issue when it is a current duplicate, else null: a hint, never a satisfaction. */
+  canonical: workRelationEndpointSchema.nullable(),
+  remedy: workDependencyRemedySchema
+});
+var workDependencyGateSchema = z12.object({
+  issueId: id12,
+  teamId: id12,
+  satisfied: z12.boolean(),
+  blockerCount: z12.number().int().nonnegative(),
+  items: z12.array(workUnsatisfiedDependencySchema),
+  nextCursor: z12.string().nullable(),
+  /**
+   * Imported blockers an import commit could not record as relations (DRI-306), unresolved until DRI-308 resolves or
+   * dismisses them: each keeps `satisfied` false (reason `pending_import`). The source key of the blocker, which resolved
+   * to no Drisp Issue, the batch, and why it is pending. Up to 20, on the first page only; omitted when
+   * there are none. Only a blocker that resolved to no Drisp Issue counts.
+   */
+  pendingImports: z12.array(z12.object({
+    reason: z12.literal("pending_import"),
+    batchId: id12,
+    from: z12.object({ idNamespace: z12.string(), externalId: z12.string() }),
+    /** Why the commit left it pending: `pending_relation` (an endpoint not resolved) or the refusal it met. */
+    importReason: z12.string()
+  })).optional(),
+  /** Whether there are more pending imported blockers than listed (DRI-306); present with `pendingImports`. */
+  pendingImportsMore: z12.boolean().optional()
+});
+var workRelationActivityKindSchema = z12.enum(["issue_relation.added", "issue_relation.removed"]);
+var workRelationActivitySchema = workActivitySchema.extend({
+  subject: z12.object({ kind: z12.literal("relation"), id: id12 }),
+  kind: workRelationActivityKindSchema
+});
+var workIssueRelationPageSchema = workPageSchema(workIssueRelationSchema);
+var workRelationActivityPageSchema = workPageSchema(workRelationActivitySchema);
+var envelope9 = { version: z12.literal(workCommandVersion), commandId: z12.string().min(1).max(200), teamId: id12 };
+var workRelationCommandSchema = z12.discriminatedUnion("type", [
+  /**
+   * Records a relation from the target Issue to `issue`, both active Issues of this Team. A self-link is
+   * `self_relation`; another Team's Issue `foreign_team_reference`; an existing current relation `no_change`.
+   */
+  z12.strictObject({
+    ...envelope9,
+    type: z12.literal("issue_relation.add"),
+    target: z12.strictObject({ kind: z12.literal("issue"), id: id12 }),
+    payload: z12.strictObject({ kind: workIssueRelationKindSchema, issue: workRefSchema })
+  }),
+  /** Ends a current relation, attributed; the period stays in history. Removing a removed one is `no_change`. */
+  z12.strictObject({
+    ...envelope9,
+    type: z12.literal("issue_relation.remove"),
+    target: z12.strictObject({ kind: z12.literal("relation"), id: id12 }),
+    payload: z12.strictObject({ reason: z12.string().trim().min(1).max(2e3).optional() })
+  })
+]);
+var workRelationCommandTypes = workRelationCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkRelationCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workRelationCommandTypes.includes(type);
+}
+var workRelationCommandResultSchema = z12.object({
+  commandId: id12,
+  type: z12.string(),
+  teamId: id12,
+  status: z12.enum(["accepted", "completed"]),
+  replayed: z12.boolean(),
+  recordedAt: timestamp10,
+  activityId: id12,
+  outcome: z12.discriminatedUnion("kind", [z12.object({ kind: z12.literal("relation"), relation: workIssueRelationSchema })])
+});
+var workRelationErrorCodes = [
+  "self_relation",
+  "dependency_cycle",
+  "duplicate_cycle",
+  "duplicate_chain",
+  "duplicate_conflict",
+  "dependency_unsatisfied",
+  "dependency_status_unknown"
+];
+var pendingKey = z12.object({ idNamespace: z12.string(), externalId: z12.string() });
+var workPendingRelationKindSchema = z12.enum(["blocks", "duplicates", "related", "parent"]);
+var workPendingRelationDispositions = ["pending", "resolved", "dismissed", "superseded_by_local_edit", "endpoint_tombstoned"];
+var workPendingRelationDispositionSchema = z12.enum(workPendingRelationDispositions);
+var workPendingRelationAttemptOutcomeSchema = z12.enum(["unresolvable_cycle", "invalid_mapping", "local_parent_differs"]);
+var workPendingRelationSchema = z12.object({
+  id: id12,
+  teamId: id12,
+  spaceId: id12,
+  kind: workPendingRelationKindSchema,
+  /** Each endpoint's complete source key and the Drisp Issue it resolves to, null while it has none. */
+  from: z12.object({ key: pendingKey, issueId: id12.nullable() }),
+  to: z12.object({ key: pendingKey, issueId: id12.nullable() }),
+  /** For `blocks`, the dependent Drisp Issue whose gate it may close; null otherwise or while the dependent is missing. */
+  blockedIssueId: id12.nullable(),
+  /** The import that recorded it: the batch and its item. */
+  import: z12.object({ batchId: id12, itemSeq: z12.number().int() }),
+  /** Why the commit left it pending (`pending_relation`, `existing_endpoints`, `local_parent_differs`, a refusal code). */
+  reason: z12.string(),
+  disposition: workPendingRelationDispositionSchema,
+  /** Whether it closes `blockedIssueId`'s dependency gate now. */
+  blocking: z12.boolean(),
+  guard: z12.object({ childId: id12, parentId: id12.nullable(), parentChangeSeq: z12.number().int().nonnegative() }).nullable(),
+  lastAttempt: z12.object({
+    outcome: workPendingRelationAttemptOutcomeSchema,
+    code: z12.string().nullable(),
+    at: timestamp10,
+    batchId: id12.nullable(),
+    commandId: id12.nullable()
+  }).nullable(),
+  /** Who or what settled it, when, by which command or import, and what it wrote. Null while pending. */
+  settlement: z12.object({
+    by: workActorSchema,
+    at: timestamp10,
+    commandId: id12,
+    batchId: id12.nullable(),
+    reason: z12.string().nullable(),
+    code: z12.string().nullable(),
+    relationId: id12.nullable(),
+    parentId: id12.nullable()
+  }).nullable(),
+  recordedAt: timestamp10
+});
+var workPendingRelationPageSchema = workPageSchema(workPendingRelationSchema);
+var workPendingRelationActivityKindSchema = z12.enum([
+  "pending_relation.resolved",
+  "pending_relation.dismissed",
+  "pending_relation.superseded",
+  "pending_relation.tombstoned",
+  "pending_relation.attempted"
+]);
+var workPendingRelationActivitySchema = workActivitySchema.extend({
+  subject: z12.object({ kind: z12.literal("pending_relation"), id: id12 }),
+  kind: workPendingRelationActivityKindSchema
+});
+var workPendingRelationActivityPageSchema = workPageSchema(workPendingRelationActivitySchema);
+var workPendingRelationCommandSchema = z12.discriminatedUnion("type", [
+  /** A member's attributed dismissal: the record is settled `dismissed`, and a dismissed blocker no longer gates. */
+  z12.strictObject({
+    ...envelope9,
+    type: z12.literal("pending_relation.dismiss"),
+    target: z12.strictObject({ kind: z12.literal("pending_relation"), id: id12 }),
+    payload: z12.strictObject({ reason: z12.string().trim().min(1).max(2e3) })
+  }),
+  /**
+   * A member's explicit resolution once both endpoints resolve to Drisp Issues, through the same Work rules. It is the
+   * member's own decision, so the local-edit guard does not hold it back. A cycle or another refusal is recorded as
+   * the record's `lastAttempt` and the record stays pending; a tombstoned endpoint settles it `endpoint_tombstoned`.
+   */
+  z12.strictObject({
+    ...envelope9,
+    type: z12.literal("pending_relation.resolve"),
+    target: z12.strictObject({ kind: z12.literal("pending_relation"), id: id12 }),
+    payload: z12.strictObject({})
+  })
+]);
+var workPendingRelationCommandTypes = workPendingRelationCommandSchema.options.map((o) => o.shape.type.value);
+function isWorkPendingRelationCommand(raw) {
+  const type = raw?.type;
+  return typeof type === "string" && workPendingRelationCommandTypes.includes(type);
+}
+var workPendingRelationCommandResultSchema = z12.object({
+  commandId: id12,
+  type: z12.string(),
+  teamId: id12,
+  status: z12.enum(["accepted", "completed"]),
+  replayed: z12.boolean(),
+  recordedAt: timestamp10,
+  activityId: id12,
+  outcome: z12.discriminatedUnion("kind", [z12.object({
+    kind: z12.literal("pending_relation"),
+    pendingRelation: workPendingRelationSchema,
+    /**
+     * Whether the command took effect: a dismissal, or a resolution that wrote (or found current) the relation or
+     * parent. A resolution that could not apply is still recorded (its `lastAttempt`, Activity and receipt) and
+     * answers `applied: false` with why in `result` and `code`.
+     */
+    applied: z12.boolean(),
+    result: z12.enum([
+      "resolved",
+      "dismissed",
+      "unresolvable_cycle",
+      "invalid_mapping",
+      "local_parent_differs",
+      "superseded_by_local_edit",
+      "endpoint_tombstoned"
+    ]),
+    code: z12.string().nullable()
+  })])
+});
+var workPendingRelationErrorCodes = ["pending_relation_settled", "pending_relation_endpoint_missing"];
+
+// src/session-control.ts
+import { z as z13 } from "zod";
+var activeSessionControlCapability = "active_session_control_v1";
+var sessionControlHistoryKind = "session_control.observation";
+var sessionCapabilityNames = [
+  /** Informational guidance reaches the model inside the running Turn, at a safe opportunity, not only at its end. */
+  "guidance.active_delivery",
+  /** The harness itself records that the guidance entered the model context, with a correlation the Runner can read. */
+  "guidance.delivery_receipt",
+  /** The harness or agent acknowledges having reconciled the guidance. Never inferred from a transport receipt. */
+  "guidance.incorporation_ack",
+  /** Pause takes effect at the next tool boundary: no further model request or tool starts until unpaused. */
+  "pause.tool_boundary",
+  /** Pause suspends a tool that is already running. */
+  "pause.during_tool",
+  /** Stop one running tool while the session continues. */
+  "interrupt.tool_keep_session",
+  /** Cancelling the harness process reverses effects a tool already made. No harness is expected to support this. */
+  "cancel.rollback"
+];
+var sessionCapabilityNameSchema = z13.enum(sessionCapabilityNames);
+var capabilitySupportSchema = z13.enum(["supported", "unsupported", "unverified"]);
+var sessionCapabilitySchema = z13.strictObject({
+  support: capabilitySupportSchema,
+  /** How the harness provides it, e.g. `PostToolUse.additionalContext`. */
+  mechanism: z13.string().max(256).optional(),
+  /** What bounds it, e.g. the hook timeout. */
+  limits: z13.string().max(1024).optional(),
+  /** Where the proof is recorded: a section of docs/specs/harness-capabilities.md. */
+  evidence: z13.string().max(256)
+});
+var harnessSessionControlSchema = z13.strictObject({
+  harness: z13.enum(["claude-code", "codex"]),
+  /** The exact version string the harness printed; `unknown` when it could not be read. */
+  version: z13.string().min(1).max(128),
+  capabilities: z13.partialRecord(sessionCapabilityNameSchema, sessionCapabilitySchema)
+});
+function capabilitySupport(record, name) {
+  return record.capabilities[name]?.support ?? "unverified";
+}
+var id13 = z13.string().min(1).max(160);
+var timestamp11 = z13.iso.datetime();
+var sessionControlCommandSchema = z13.strictObject({
+  commandId: id13,
+  runId: id13,
+  intent: z13.discriminatedUnion("kind", [
+    z13.strictObject({
+      kind: z13.literal("guidance"),
+      text: z13.string().min(1).max(131072),
+      /** Ask for an incorporation acknowledgement; refused where `guidance.incorporation_ack` is not supported. */
+      requireIncorporation: z13.literal(true).optional()
+    }),
+    z13.strictObject({ kind: z13.literal("pause") }),
+    z13.strictObject({ kind: z13.literal("unpause") }),
+    z13.strictObject({ kind: z13.literal("interrupt_tool"), toolUseId: id13.optional() })
+  ])
+});
+var inFlightToolSchema = z13.strictObject({ toolUseId: id13, toolName: z13.string().max(256), startedAt: timestamp11 });
+var correlation = {
+  commandId: id13,
+  runId: id13,
+  attemptId: id13,
+  observedAt: timestamp11
+};
+var sessionControlRejectionSchema = z13.enum([
+  /** The capability is `unsupported` or `unverified` for this harness version; `capability` names it. */
+  "capability_unsupported",
+  /** The Run has no live harness session on this Runner. */
+  "no_active_session",
+  /** The session ended before a safe opportunity to deliver. */
+  "execution_ended",
+  /** `interrupt_tool` named a tool that is not running, or none is running (DRI-316). */
+  "tool_not_in_flight",
+  /** The harness mechanism would stop more than the tool asked for, so nothing is stopped (DRI-316). */
+  "target_ambiguous",
+  /** The harness refused the control request itself; `detail` carries its error (DRI-316). */
+  "harness_refused"
+]);
+var sessionControlObservationSchema = z13.discriminatedUnion("kind", [
+  /** The capability record the Runner resolved for this session, before any command. */
+  z13.strictObject({
+    kind: z13.literal("capabilities"),
+    runId: id13,
+    attemptId: id13,
+    observedAt: timestamp11,
+    record: harnessSessionControlSchema
+  }),
+  /** Transport receipt: the Runner durably accepted the command. Says nothing about the agent. */
+  z13.strictObject({ kind: z13.literal("received"), ...correlation, intent: z13.enum(["guidance", "pause", "unpause", "interrupt_tool"]) }),
+  /** Agent delivery: the harness recorded the guidance in the model context of this session. */
+  z13.strictObject({
+    kind: z13.literal("delivered"),
+    ...correlation,
+    mechanism: z13.string().max(256),
+    sessionId: id13,
+    /** The harness's own identity of the user input being processed: unchanged means the same Turn. */
+    promptId: id13.optional(),
+    /** The tool boundary the guidance was attached at. */
+    toolUseId: id13,
+    /**
+     * What proves it: the harness's own record, never the hook reply. `harness_transcript` is a session transcript
+     * entry (Claude Code); `harness_history_item` is the model-visible history item the harness reports as it records
+     * it (Codex app-server `rawResponseItem/completed`, DRI-316).
+     */
+    evidence: z13.strictObject({ source: z13.enum(["harness_transcript", "harness_history_item"]), recordId: id13 })
+  }),
+  /** Incorporation acknowledgement. Only for a harness whose `guidance.incorporation_ack` is supported. */
+  z13.strictObject({ kind: z13.literal("incorporated"), ...correlation, evidence: z13.string().max(1024) }),
+  z13.strictObject({
+    kind: z13.literal("rejected"),
+    ...correlation,
+    reason: sessionControlRejectionSchema,
+    capability: sessionCapabilityNameSchema.optional(),
+    harness: z13.string().max(64).optional(),
+    version: z13.string().max(128).optional(),
+    /** What the Runner or the harness said, e.g. which tools are in flight (DRI-316). */
+    detail: z13.string().max(1024).optional()
+  }),
+  /**
+   * An `interrupt_tool` took effect (DRI-316): the harness recorded the targeted tool's end after the Runner asked it
+   * to stop the tool. Whatever the tool already did remains; the session's later `tool` observations show it went on.
+   */
+  z13.strictObject({
+    kind: z13.literal("interrupted"),
+    ...correlation,
+    toolUseId: id13,
+    mechanism: z13.string().max(256),
+    /** The tool's end as the harness recorded it, e.g. Codex `failed` with exit code -1. */
+    harnessStatus: z13.string().max(64),
+    exitCode: z13.number().int().nullable()
+  }),
+  /** The Runner handed the guidance to the harness, but the harness never recorded it: delivery is not claimed. */
+  z13.strictObject({ kind: z13.literal("unconfirmed"), ...correlation, toolUseId: id13.optional() }),
+  /** Requested versus effective pause, and the tools still running when it was observed. */
+  z13.strictObject({
+    kind: z13.literal("state"),
+    ...correlation,
+    requested: z13.enum(["running", "paused"]),
+    effective: z13.enum(["running", "pause_pending", "paused"]),
+    inFlight: z13.array(inFlightToolSchema).max(64),
+    /** Where the session is held while `effective` is `paused`. */
+    safePoint: z13.strictObject({ hookEvent: z13.enum(["PreToolUse", "PostToolUse"]), toolUseId: id13 }).optional(),
+    /** Why a requested pause stopped being effective without an unpause. */
+    lapse: z13.enum(["hook_deadline", "session_ended"]).optional()
+  }),
+  /**
+   * The Run was cancelled while these tools were running. Cancelling stops the harness process; it does not reverse
+   * anything a tool already did, and whatever these tools started may have completed, partly completed, or not run.
+   */
+  z13.strictObject({
+    kind: z13.literal("cancelled"),
+    runId: id13,
+    attemptId: id13,
+    observedAt: timestamp11,
+    inFlight: z13.array(inFlightToolSchema).max(64),
+    rollback: z13.literal(false)
+  }),
+  /** A harness tool boundary, for correlation: which tool, in which session and Turn. */
+  z13.strictObject({
+    kind: z13.literal("tool"),
+    runId: id13,
+    attemptId: id13,
+    observedAt: timestamp11,
+    phase: z13.enum(["started", "ended"]),
+    sessionId: id13,
+    promptId: id13.optional(),
+    toolUseId: id13,
+    toolName: z13.string().max(256)
+  })
+]);
+
+// src/client-integration.ts
+import { z as z14 } from "zod";
+var workClientContract = 1;
+var workClientContractHeader = "drisp-client-contract";
+var workClientContractMinimum = 1;
+var workAuthoritySchema = z14.object({
+  teamId: z14.string().min(1),
+  work: z14.enum(["legacy", "core"]),
+  contract: z14.object({ current: z14.number().int().positive(), minimum: z14.number().int().positive() })
+});
+var workClientOperations = ["work.read", "history.read"];
+function selectWorkPath(authority, client = workClientContract) {
+  if (authority === null) return { kind: "legacy", work: "legacy" };
+  if (client < authority.contract.minimum)
+    return { kind: "unsupported", code: "client_upgrade_required", minimum: authority.contract.minimum, current: authority.contract.current };
+  if (client > authority.contract.current)
+    return { kind: "unsupported", code: "hub_upgrade_required", minimum: authority.contract.minimum, current: authority.contract.current };
+  if (authority.work === "legacy") return { kind: "legacy", work: "legacy" };
+  return { kind: "work_only", work: "core" };
+}
+function supportedOperations(path) {
+  if (path.kind === "unsupported" || path.kind === "legacy") return [];
+  return [...workClientOperations];
+}
 
 // src/v2.ts
-var protocolVersion = { major: 2, minor: 3 };
+var protocolVersion = { major: 2, minor: 4 };
 var conversationContinuationCapability = "conversation_continuation";
 var abandonedConversationContinuationCapability = "abandoned_conversation_continuation";
 var repositoryAccessCapability = "repository_checkout_v1";
@@ -305,30 +2907,32 @@ var workflowInstallCapability = "workflow_install_v1";
 var runDelegationCapability = "run_delegation_v1";
 var orchestratorGuidanceCapability = "orchestrator_guidance_v1";
 var runUsageCapability = "run_usage_v1";
+var coordinationSupervisionCapability = "coordination_supervision_v1";
+var buildGatesCapability = "build_gates_v1";
 var delegationTokenPrefix = "drisp_dlg_";
-var runArtifactNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,63}$/);
+var runArtifactNameSchema = z15.string().regex(/^[a-z][a-z0-9_]{0,63}$/);
 var runArtifactMaxBytes = 64 * 1024;
-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 secretEnvironmentSchema = z15.record(
+  z15.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_]+)$/),
+  z15.string().regex(/^projects\/[a-zA-Z0-9-]+\/secrets\/[a-zA-Z0-9_-]+\/versions\/(?:latest|[0-9]+)$/)
 );
-var permissionAnswerSchema = z3.strictObject({
-  kind: z3.literal("permission"),
-  decision: z3.enum(["allow", "deny"]),
-  reason: z3.string().max(4096).optional()
-});
-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 = z3.iso.datetime();
-var scopeSchema = z3.discriminatedUnion("visibility", [
-  z3.strictObject({ visibility: z3.literal("organization") }),
-  z3.strictObject({ visibility: z3.literal("private"), ownerUserId: id2 })
-]);
-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({
+var permissionAnswerSchema = z15.strictObject({
+  kind: z15.literal("permission"),
+  decision: z15.enum(["allow", "deny"]),
+  reason: z15.string().max(4096).optional()
+});
+var id14 = z15.string().min(1).max(160);
+var sequence2 = z15.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var positive = sequence2.refine((n) => n > 0);
+var timestamp12 = z15.iso.datetime();
+var scopeSchema = z15.discriminatedUnion("visibility", [
+  z15.strictObject({ visibility: z15.literal("organization") }),
+  z15.strictObject({ visibility: z15.literal("private"), ownerUserId: id14 })
+]);
+var installedWorkflowsSchema = z15.array(InstalledWorkflowSchema).max(256);
+var harnessSchema = z15.enum(["claude-code", "codex"]);
+var harnessReadinessSchema = z15.strictObject({ installed: z15.boolean(), signedIn: z15.boolean() });
+var runnerReadinessSchema = z15.strictObject({
   "claude-code": harnessReadinessSchema.optional(),
   codex: harnessReadinessSchema.optional()
 });
@@ -343,27 +2947,27 @@ function readinessFixCommand(harness, readiness) {
   return void 0;
 }
 var runnerUpdateCommand = "npm i -g @drisp/cli";
-var interruptionSchema = z3.strictObject({
-  interruptionId: id2,
+var interruptionSchema = z15.strictObject({
+  interruptionId: id14,
   revision: positive,
   /** `waiting` (root ADR-0008) is non-human: a Run parked until one of its children closes or parks. */
-  kind: z3.enum(["permission", "question", "guidance", "recovery", "waiting"]),
-  message: z3.string().max(16384),
+  kind: z15.enum(["permission", "question", "guidance", "recovery", "waiting"]),
+  message: z15.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()
+  respondent: z15.enum(["orchestrator"]).optional(),
+  requestId: id14.optional()
 });
-var workflowIdentitySchema = z3.strictObject({
-  name: z3.string().min(1).max(128),
-  version: z3.string().min(1).max(128).optional()
+var workflowIdentitySchema = z15.strictObject({
+  name: z15.string().min(1).max(128),
+  version: z15.string().min(1).max(128).optional()
 });
-var buildCloseReasonSchema = z3.enum([
+var buildCloseReasonSchema = z15.enum([
   "workflow_template_mismatch",
   "child_project_dir_invalid",
   "build_not_approved",
   "approval_question_missing"
 ]);
-var runCloseReasonSchema = z3.enum([
+var runCloseReasonSchema = z15.enum([
   "execution_terminal",
   "cancelled_before_start",
   "admission_failed",
@@ -381,53 +2985,53 @@ var runCloseReasonSchema = z3.enum([
   ...buildCloseReasonSchema.options
 ]);
 var factIdentity = {
-  runId: id2,
-  attemptId: id2,
+  runId: id14,
+  attemptId: id14,
   executionRevision: positive,
-  emittedAt: timestamp
+  emittedAt: timestamp12
 };
-var runUsageSchema = z3.strictObject({ counted: sequence, cacheRead: sequence });
+var runUsageSchema = z15.strictObject({ counted: sequence2, cacheRead: sequence2 });
 var reportedUsage = { usage: runUsageSchema.optional() };
-var controlRecordSchema = z3.discriminatedUnion("kind", [
+var controlRecordSchema = z15.discriminatedUnion("kind", [
   /** Instance-scoped, not tied to a Run: the full replacement inventory of installed Workflows. */
-  z3.strictObject({ kind: z3.literal("workflows.changed"), workflows: installedWorkflowsSchema }),
+  z15.strictObject({ kind: z15.literal("workflows.changed"), workflows: installedWorkflowsSchema }),
   /** Instance-scoped, not tied to a Run: the Runner's full Readiness, sent when it changes after hello. */
-  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)
+  z15.strictObject({ kind: z15.literal("readiness.changed"), readiness: runnerReadinessSchema }),
+  z15.strictObject({ kind: z15.literal("assignment.accepted"), runId: id14, attemptId: id14 }),
+  z15.strictObject({
+    kind: z15.literal("assignment.rejected"),
+    runId: id14,
+    attemptId: id14,
+    reason: z15.string().max(1024)
   }),
-  z3.strictObject({
-    kind: z3.literal("run.started"),
+  z15.strictObject({
+    kind: z15.literal("run.started"),
     ...factIdentity,
     /** Absent from runners that predate Workflow reporting. */
     workflow: workflowIdentitySchema.optional()
   }),
-  z3.strictObject({ kind: z3.literal("run.resumed"), ...factIdentity }),
-  z3.strictObject({
-    kind: z3.literal("run.attention"),
+  z15.strictObject({ kind: z15.literal("run.resumed"), ...factIdentity }),
+  z15.strictObject({
+    kind: z15.literal("run.attention"),
     ...factIdentity,
     interruption: interruptionSchema,
-    occupancy: z3.enum(["held", "released"]),
-    historyThrough: sequence,
-    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) })
+    occupancy: z15.enum(["held", "released"]),
+    historyThrough: sequence2,
+    continuation: z15.discriminatedUnion("kind", [
+      z15.strictObject({ kind: z15.literal("live_request") }),
+      z15.strictObject({ kind: z15.literal("local_checkpoint"), checkpointId: id14 }),
+      z15.strictObject({ kind: z15.literal("portable_checkpoint"), checkpointId: id14 }),
+      z15.strictObject({ kind: z15.literal("repair_required"), detail: z15.string().max(4096) })
     ]),
     ...reportedUsage
   }),
-  z3.strictObject({
-    kind: z3.literal("run.finished"),
+  z15.strictObject({
+    kind: z15.literal("run.finished"),
     ...factIdentity,
-    status: z3.enum(["completed", "failed", "cancelled"]),
-    historyThrough: sequence,
+    status: z15.enum(["completed", "failed", "cancelled"]),
+    historyThrough: sequence2,
     /** No setup/harness executed and no workspace was produced; safe to retire without export. */
-    workspaceUnavailable: z3.literal(true).optional(),
+    workspaceUnavailable: z15.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.
@@ -439,262 +3043,290 @@ var controlRecordSchema = z3.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.
    */
-  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)
+  z15.strictObject({ kind: z15.literal("run.usage"), runId: id14, attemptId: id14, ...runUsageSchema.shape }),
+  z15.strictObject({ kind: z15.literal("command.applied"), runId: id14, attemptId: id14, commandId: id14 }),
+  z15.strictObject({
+    kind: z15.literal("command.rejected"),
+    runId: id14,
+    attemptId: id14,
+    commandId: id14,
+    reason: z15.string().max(1024)
   }),
-  z3.strictObject({ kind: z3.literal("revoked_not_started"), runId: id2, attemptId: id2 })
+  z15.strictObject({ kind: z15.literal("revoked_not_started"), runId: id14, attemptId: id14 })
 ]);
-var repositoryRefSchema = z3.string().min(1).max(512).regex(
+var repositoryRefSchema = z15.string().min(1).max(512).regex(
   /^(?![-/])(?!.*\.\.)(?!.*@\{)(?!.*(?:^|\/)\.)(?!.*\.lock(?:\/|$))(?!.*\/\/)[^\x00-\x20\x7f~^:?*\[\\]+(?<![/.])$/
 );
-var repositoryWorkingDirectorySchema = z3.string().min(1).max(1024).regex(
+var repositoryWorkingDirectorySchema = z15.string().min(1).max(1024).regex(
   /^(?:\.|(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?!.*(?:^|\/)\.git(?:\/|$))[^\x00-\x1f\x7f\\:]+(?<!\/))$/
 );
 var repositoryIdentity = {
-  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_.-]+$/)
+  repositoryId: z15.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  installationId: z15.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  owner: z15.string().min(1).max(100).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/),
+  name: z15.string().min(1).max(100).regex(/^(?!\.{1,2}$)[a-zA-Z0-9_.-]+$/)
 };
-var repositoryBindingSchema = z3.strictObject({
-  id: id2,
-  label: z3.string().min(1).max(160),
+var repositoryBindingSchema = z15.strictObject({
+  id: id14,
+  label: z15.string().min(1).max(160),
   ...repositoryIdentity,
   defaultRef: repositoryRefSchema,
   workingDirectory: repositoryWorkingDirectorySchema,
-  setupCommands: z3.array(z3.string().min(1).max(8192)).max(16),
+  setupCommands: z15.array(z15.string().min(1).max(8192)).max(16),
   revision: positive,
-  enabled: z3.boolean()
+  enabled: z15.boolean()
 });
-var repositorySourceSchema = z3.strictObject({
-  bindingId: id2,
+var repositorySourceSchema = z15.strictObject({
+  bindingId: id14,
   ...repositoryIdentity,
   ref: repositoryRefSchema,
-  commitSha: z3.string().regex(/^[0-9a-f]{40}$/),
+  commitSha: z15.string().regex(/^[0-9a-f]{40}$/),
   branch: repositoryRefSchema,
   workingDirectory: repositoryWorkingDirectorySchema,
-  setupCommands: z3.array(z3.string().min(1).max(8192)).max(16),
+  setupCommands: z15.array(z15.string().min(1).max(8192)).max(16),
   configRevision: positive
 });
-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_-]*$/),
+var workflowSourceSchema = z15.string().max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*$/);
+var workflowReferenceSchema = z15.union([
+  z15.string().max(512),
+  z15.strictObject({
+    name: z15.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/),
     source: workflowSourceSchema.optional(),
-    ref: z3.string().min(1).max(512).optional(),
-    version: z3.string().min(1).max(128).regex(/^\d[A-Za-z0-9_.+-]*$/).optional()
+    ref: z15.string().min(1).max(512).optional(),
+    version: z15.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 = z3.strictObject({
-  prompt: z3.string().min(1).max(131072),
-  projectDir: z3.string().min(1).max(4096),
+var gateModeSchema = z15.enum(["ask", "auto"]);
+var gateOverridesSchema = z15.strictObject({
+  planApproval: gateModeSchema.optional(),
+  merge: gateModeSchema.optional(),
+  budget: gateModeSchema.optional(),
+  irreversible: gateModeSchema.optional()
+});
+var tokenBudgetSchema = z15.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var runSpecSchema = z15.strictObject({
+  prompt: z15.string().min(1).max(131072),
+  projectDir: z15.string().min(1).max(4096),
   harness: harnessSchema,
   workflow: workflowReferenceSchema.optional(),
-  repository: repositorySourceSchema.optional()
-});
-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: z3.discriminatedUnion("kind", [
-    z3.strictObject({
-      kind: z3.literal("start"),
-      sessionId: id2,
+  repository: repositorySourceSchema.optional(),
+  /** DRI-367: the Build's gates, applied as the "Build" source (tighten only). Only to a `build_gates_v1` runner. */
+  gates: gateOverridesSchema.optional(),
+  /**
+   * DRI-367: the member's token budget for this Run's own stop (root ADR-0011 as amended by ADR-0018), at start. It
+   * replaces the Workflow's `maxRunTokens`. A `setBudget` rewrites the Run's budget on the Hub, never this field: a
+   * grant's `tokenBudget` is the current value. Only to a `build_gates_v1` runner.
+   */
+  tokenBudget: tokenBudgetSchema.optional()
+});
+var runKeySchema = z15.string().min(1).max(160);
+var delegationSchema = z15.strictObject({
+  maxChildren: z15.number().int().min(1).max(64).optional(),
+  tokenBudget: tokenBudgetSchema
+});
+var commandSchema = z15.strictObject({
+  commandId: id14,
+  hubEpoch: id14,
+  runId: id14,
+  expectedRecordRevision: sequence2.optional(),
+  intent: z15.discriminatedUnion("kind", [
+    z15.strictObject({
+      kind: z15.literal("start"),
+      sessionId: id14,
       /**
        * 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: id2.optional(),
-      computeProfileId: id2.optional(),
+      runnerId: id14.optional(),
+      computeProfileId: id14.optional(),
       scope: scopeSchema,
       spec: runSpecSchema,
       key: runKeySchema.optional(),
-      /** Member starts only. */
-      delegation: delegationSchema.optional(),
-      /** Delegated starts only, and required on them. */
-      parent: runParentIntentSchema.optional()
+      /** Member starts only: mints the Run a delegation token per attempt. */
+      delegation: delegationSchema.optional()
     }),
-    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,
+    z15.strictObject({ kind: z15.literal("cancel") }),
+    z15.strictObject({ kind: z15.literal("abandon") }),
+    z15.strictObject({ kind: z15.literal("steer"), text: z15.string().min(1).max(131072) }),
+    z15.strictObject({
+      kind: z15.literal("answer"),
+      interruptionId: id14,
       expectedInterruptionRevision: positive,
-      requestId: id2.optional(),
-      answer: z3.json()
+      requestId: id14.optional(),
+      answer: z15.json()
     }),
-    z3.strictObject({
-      kind: z3.literal("resume"),
-      interruptionId: id2,
-      guidance: z3.string().max(131072).optional()
+    z15.strictObject({
+      kind: z15.literal("resume"),
+      interruptionId: id14,
+      guidance: z15.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.
+     * A member rewrites a Run's own token budget (root ADR-0011, DRI-367), never below what it used. With `resume`, a
+     * parked Run is resumed when the value is strictly greater. Hub-only: never delivered to a Runner.
      */
-    z3.strictObject({
-      kind: z3.literal("setBudget"),
-      tokenBudget: delegationSchema.shape.tokenBudget,
-      resume: z3.boolean().optional()
+    z15.strictObject({
+      kind: z15.literal("setBudget"),
+      tokenBudget: tokenBudgetSchema,
+      resume: z15.boolean().optional()
     })
   ])
 });
-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,
+var deliveredCommandSchema = commandSchema.extend({ orchestratorRunId: id14.optional() });
+var grantSchema = z15.strictObject({
+  commandId: id14,
+  hubEpoch: id14,
+  runId: id14,
+  sessionId: id14,
+  runnerId: id14,
+  installationId: id14,
+  attemptId: id14,
   generation: positive,
-  baseExecutionRevision: sequence,
-  baseHistorySeq: sequence,
-  cloudHistoryThrough: sequence,
-  purpose: z3.enum(["start", "resume"]),
+  baseExecutionRevision: sequence2,
+  baseHistorySeq: sequence2,
+  cloudHistoryThrough: sequence2,
+  purpose: z15.enum(["start", "resume"]),
   spec: runSpecSchema,
-  continuation: z3.json().optional(),
+  continuation: z15.json().optional(),
   /** Authenticated source of a delegated continuation; absence retains member semantics. */
-  orchestratorRunId: id2.optional(),
+  orchestratorRunId: id14.optional(),
   /** A new Run in a durable conversation; never resumes the predecessor's lifecycle. */
-  previousRun: z3.strictObject({
-    runId: id2,
-    executionRevision: sequence,
-    historyProduced: sequence,
+  previousRun: z15.strictObject({
+    runId: id14,
+    executionRevision: sequence2,
+    historyProduced: sequence2,
     /** Hub-confirmed administrative closure; allows an exact parked predecessor snapshot. */
-    closeReason: z3.literal("abandoned").optional(),
-    checkpoint: z3.strictObject({ checkpointId: id2, checksum: z3.string().regex(/^[a-f0-9]{64}$/) }).optional()
+    closeReason: z15.literal("abandoned").optional(),
+    checkpoint: z15.strictObject({ checkpointId: id14, checksum: z15.string().regex(/^[a-f0-9]{64}$/) }).optional()
   }).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: z3.string().min(32).max(256).optional(),
-  /** Copied from the start intent of a delegated child. */
-  parent: runParentSchema.optional(),
+  checkpoint: z15.strictObject({ checkpointId: id14, checksum: z15.string().regex(/^[a-f0-9]{64}$/) }).optional(),
+  /**
+   * This attempt's delegation token: for a Run started with `delegation` or a coordinated Run's credential, only to a
+   * `run_delegation_v1` Runner.
+   */
+  delegationToken: z15.string().min(32).max(256).optional(),
   /** The runner reports this attempt's usage: set only for a `run_usage_v1` Runner. */
-  reportUsage: z3.literal(true).optional()
+  reportUsage: z15.literal(true).optional(),
+  /**
+   * DRI-322: open the session-control channel for this attempt: set only for a coordination-bound Run on a Runner that
+   * advertises `active_session_control_v1`. Any other Run (a chat, a Build) gets no relay.
+   */
+  sessionControl: z15.literal(true).optional(),
+  /**
+   * DRI-330: the Run works under a coordinating parent (a coordinated specialist, or a child execution's coordinator):
+   * its NEEDS_ORCHESTRATOR question is that parent's to answer. Set only on a `coordination_supervision_v1` runner.
+   */
+  supervised: z15.literal(true).optional(),
+  /**
+   * DRI-367: the Run's current token budget, for a Run started with `spec.tokenBudget`: what the member last set
+   * (`setBudget`), so a resumed attempt stops at the new value. Only to a `build_gates_v1` runner.
+   */
+  tokenBudget: tokenBudgetSchema.optional(),
+  /**
+   * DRI-367: the Team's gates, the floor of the gate resolution with the runner's global config. Reserved: the Hub has
+   * no Team gate setting yet, so it never sets this. Only to a `build_gates_v1` runner.
+   */
+  teamGates: gateOverridesSchema.optional()
 });
-var historyRecordSchema = z3.strictObject({
-  eventId: id2,
-  attemptId: id2,
-  emittedAt: timestamp,
-  kind: z3.string().min(1).max(128),
-  data: z3.json()
+var historyRecordSchema = z15.strictObject({
+  eventId: id14,
+  attemptId: id14,
+  emittedAt: timestamp12,
+  kind: z15.string().min(1).max(128),
+  data: z15.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),
+var runnerFrameSchema = z15.discriminatedUnion("type", [
+  z15.strictObject({
+    type: z15.literal("hello"),
+    role: z15.literal("runner"),
+    protocol: z15.strictObject({ major: z15.literal(2), minor: sequence2 }),
+    runnerId: id14,
+    installationId: id14,
+    softwareVersion: z15.string().max(128),
+    capabilities: z15.array(z15.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: z3.strictObject({ firstRetainedSeq: positive, lastProducedSeq: sequence })
+    control: z15.strictObject({ firstRetainedSeq: positive, lastProducedSeq: sequence2 })
   }),
-  z3.strictObject({
-    type: z3.literal("control.batch"),
+  z15.strictObject({
+    type: z15.literal("control.batch"),
     firstSeq: positive,
-    records: z3.array(controlRecordSchema).min(1).max(128)
+    records: z15.array(controlRecordSchema).min(1).max(128)
   }),
-  z3.strictObject({
-    type: z3.literal("history.batch"),
-    runId: id2,
+  z15.strictObject({
+    type: z15.literal("history.batch"),
+    runId: id14,
     firstSeq: positive,
-    records: z3.array(historyRecordSchema).min(1).max(128)
+    records: z15.array(historyRecordSchema).min(1).max(128)
   }),
-  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: z3.boolean(),
-    runs: z3.array(
-      z3.strictObject({
-        runId: id2,
-        attemptId: id2,
-        executionRevision: sequence,
-        phase: z3.enum(["admitted", "prepared", "executing", "parked", "terminal", "recovery"])
+  z15.strictObject({ type: z15.literal("ping"), nonce: id14 }),
+  z15.strictObject({
+    type: z15.literal("reconcile.page"),
+    inventoryId: id14.default("single-page"),
+    page: sequence2.default(0),
+    complete: z15.boolean(),
+    runs: z15.array(
+      z15.strictObject({
+        runId: id14,
+        attemptId: id14,
+        executionRevision: sequence2,
+        phase: z15.enum(["admitted", "prepared", "executing", "parked", "terminal", "recovery"])
       })
     ).max(128)
   })
 ]);
-var runViewSchema = z3.object({
-  runId: id2,
-  sessionId: id2,
-  runnerId: id2,
-  computeProfileId: id2.optional(),
+var runViewSchema = z15.object({
+  runId: id14,
+  sessionId: id14,
+  runnerId: id14,
+  computeProfileId: id14.optional(),
   scope: scopeSchema,
   recordRevision: positive,
-  label: z3.string().max(160).optional(),
+  label: z15.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: 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 start's `delegation`, as the Run's token grant. Not strict: a client never refuses a view for a field it does not read. */
+  delegation: z15.object({ tokenBudget: tokenBudgetSchema }).optional(),
   /** The largest cumulative usage the Run's Runner reported; absent until one does (an older Runner never does). */
   usage: runUsageSchema.optional(),
+  /**
+   * DRI-367: a Run's own token budget (started with `spec.tokenBudget`), as the member last set it, and how many
+   * `setBudget` commands raised it. Absent for any other Run.
+   */
+  tokenBudget: tokenBudgetSchema.optional(),
+  raiseCount: sequence2.optional(),
   /** Resolved by the runner at start; absent until the Run starts and for runners that predate reporting. */
   workflow: workflowIdentitySchema.optional(),
-  execution: z3.object({
-    status: z3.enum(["running", "awaiting_attention", "completed", "failed", "cancelled"]),
+  execution: z15.object({
+    status: z15.enum(["running", "awaiting_attention", "completed", "failed", "cancelled"]),
     revision: positive,
-    attemptId: id2,
-    occupancy: z3.enum(["held", "released"]),
-    startedAt: timestamp.optional(),
-    endedAt: timestamp.optional(),
+    attemptId: id14,
+    occupancy: z15.enum(["held", "released"]),
+    startedAt: timestamp12.optional(),
+    endedAt: timestamp12.optional(),
     interruption: interruptionSchema.optional()
   }).nullable(),
-  scheduling: z3.enum(["queued", "dispatching", "admitted", "idle"]),
-  closed: z3.boolean(),
-  closeReason: z3.string().optional(),
-  cancellation: id2.optional(),
+  scheduling: z15.enum(["queued", "dispatching", "admitted", "idle"]),
+  closed: z15.boolean(),
+  closeReason: z15.string().optional(),
+  cancellation: id14.optional(),
   pendingResume: commandSchema.shape.intent.optional(),
   /** Derived per viewer; absent on older Hubs. Never grants execution authority. */
-  runnerStopped: z3.boolean().optional(),
-  canAbandon: z3.boolean().optional(),
-  historyThrough: sequence,
-  expectedHistoryThrough: sequence.optional(),
-  createdAt: sequence,
-  checkpoint: z3.object({ id: id2, state: z3.enum(["pending", "ready"]), checksum: z3.string().optional() }).optional()
-});
-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 })
+  runnerStopped: z15.boolean().optional(),
+  canAbandon: z15.boolean().optional(),
+  historyThrough: sequence2,
+  expectedHistoryThrough: sequence2.optional(),
+  createdAt: sequence2,
+  checkpoint: z15.object({ id: id14, state: z15.enum(["pending", "ready"]), checksum: z15.string().optional() }).optional()
+});
+var clientFrameSchema = z15.discriminatedUnion("type", [
+  z15.strictObject({ type: z15.literal("watch"), hubEpoch: id14, runIds: z15.array(id14).max(100) }),
+  z15.strictObject({ type: z15.literal("watch.ack"), subscriptionId: id14, through: sequence2 }),
+  z15.strictObject({ type: z15.literal("command.submit"), command: commandSchema }),
+  z15.strictObject({ type: z15.literal("ping"), nonce: id14 })
 ]);
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") {
@@ -705,78 +3337,78 @@ 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 = z3.string().min(1).max(4096).refine(
+var checkpointPathSchema = z15.string().min(1).max(4096).refine(
   (path) => !path.startsWith("/") && !path.includes("\\") && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".git")
 );
-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),
+var checkpointSchema = z15.strictObject({
+  version: z15.literal(1),
+  checkpointId: z15.string().min(1),
+  orgId: z15.string().min(1),
+  phase: z15.enum(["parked", "terminal"]),
+  runId: z15.string().min(1),
+  sessionId: z15.string().min(1),
+  sourceAttemptId: z15.string().min(1),
+  executionRevision: z15.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  historyProduced: z15.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  historyAck: z15.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   grant: grantSchema,
-  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() })
+  gitHead: z15.string().regex(/^[0-9a-f]{40,64}$/),
+  gitBase: z15.string().regex(/^[0-9a-f]{40,64}$/).optional(),
+  gitBundle: z15.string(),
+  indexPatch: z15.string(),
+  files: z15.array(
+    z15.strictObject({ path: checkpointPathSchema, content: z15.string(), executable: z15.boolean() })
   ).max(1e5),
-  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 })
+  deleted: z15.array(checkpointPathSchema).max(1e5),
+  sessionRows: z15.array(z15.strictObject({ kind: z15.string(), id: z15.string(), payload: z15.string() })),
+  history: z15.array(
+    z15.strictObject({ seq: z15.number().int().positive(), record: historyRecordSchema })
   )
 });
 var connectCodeAlphabet = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
-var connectCodeSchema = z3.string().regex(/^[A-HJKMNP-Z2-9]{8}$/);
-var connectCodeRequestSchema = z3.strictObject({ hubEpoch: z3.string() });
-var connectCodeResponseSchema = z3.strictObject({
+var connectCodeSchema = z15.string().regex(/^[A-HJKMNP-Z2-9]{8}$/);
+var connectCodeRequestSchema = z15.strictObject({ hubEpoch: z15.string() });
+var connectCodeResponseSchema = z15.strictObject({
   code: connectCodeSchema,
-  expiresAt: sequence
-});
-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 = z3.strictObject({
-  error: z3.literal("runner_already_connected"),
-  orgId: id2,
-  runnerId: id2,
-  name: z3.string()
-});
-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(),
+  expiresAt: sequence2
+});
+var connectRedeemRequestSchema = z15.strictObject({
+  code: z15.string().min(8).max(16),
+  installationId: id14,
+  hostname: z15.string().min(1).max(255),
+  os: z15.string().min(1).max(64),
+  softwareVersion: z15.string().min(1).max(128)
+});
+var connectRedeemResponseSchema = z15.strictObject({
+  orgId: id14,
+  hubEpoch: z15.string(),
+  runnerId: id14,
+  installationId: id14,
+  name: z15.string(),
+  token: z15.string().min(32),
+  credentialId: id14,
+  expiresAt: sequence2
+});
+var connectAlreadyConnectedSchema = z15.strictObject({
+  error: z15.literal("runner_already_connected"),
+  orgId: id14,
+  runnerId: id14,
+  name: z15.string()
+});
+var audienceSchema = z15.enum(["personal", "team"]);
+var runnerListEntrySchema = z15.object({
+  id: id14,
+  online: z15.number(),
+  capacity: z15.number(),
+  managed: z15.number(),
+  draining: z15.number(),
+  stopped: z15.number(),
+  name: z15.string().nullable(),
+  connectedBy: z15.string().nullable(),
   audience: audienceSchema.nullable(),
-  softwareVersion: z3.string().nullable(),
+  softwareVersion: z15.string().nullable(),
   /** Milliseconds since the epoch of the last hello or disconnect; null before the first connection. */
-  lastSeen: sequence.nullable(),
+  lastSeen: sequence2.nullable(),
   /** Absent when the runner has not reported an inventory: unknown, not none. */
   workflows: installedWorkflowsSchema.optional(),
   /**
@@ -784,125 +3416,119 @@ var runnerListEntrySchema = z3.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: z3.boolean().optional(),
+  readOnly: z15.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: z3.boolean().optional(),
+  updateRequired: z15.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: z3.boolean().optional()
+  needsOwner: z15.boolean().optional()
 });
-var teamDefaultSchema = z3.discriminatedUnion("kind", [
-  z3.strictObject({ kind: z3.literal("runner"), runnerId: id2 }),
-  z3.strictObject({ kind: z3.literal("profile"), profileId: id2 })
+var teamDefaultSchema = z15.discriminatedUnion("kind", [
+  z15.strictObject({ kind: z15.literal("runner"), runnerId: id14 }),
+  z15.strictObject({ kind: z15.literal("profile"), profileId: id14 })
 ]);
-var teamDefaultRequestSchema = z3.strictObject({
-  hubEpoch: z3.string(),
+var teamDefaultRequestSchema = z15.strictObject({
+  hubEpoch: z15.string(),
   teamDefault: teamDefaultSchema.nullable()
 });
-var runnerUpdateRequestSchema = z3.strictObject({
-  hubEpoch: z3.string(),
-  name: z3.string().max(100).optional(),
-  capacity: z3.number().int().min(1).max(64).optional(),
+var runnerUpdateRequestSchema = z15.strictObject({
+  hubEpoch: z15.string(),
+  name: z15.string().max(100).optional(),
+  capacity: z15.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 = z3.union([
+var runsGoToSchema = z15.union([
   /** The viewer's own Runner: Personal, or one they connected that was widened to Team (DRI-42). */
-  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 }),
+  z15.strictObject({ via: z15.literal("personal"), runnerId: id14 }),
+  z15.strictObject({ via: z15.literal("team_default"), runnerId: id14 }),
+  z15.strictObject({ via: z15.literal("team_default"), profileId: id14 }),
   /** `runner_needs_owner`: the Team default is a Runner paused because the member who connected it left. */
-  z3.strictObject({ via: z3.literal("none"), reason: z3.enum(["no_runner_available", "runner_needs_owner"]) })
+  z15.strictObject({ via: z15.literal("none"), reason: z15.enum(["no_runner_available", "runner_needs_owner"]) })
 ]);
-var runnerListSchema = z3.object({
-  capabilities: z3.record(z3.string(), z3.boolean()).optional(),
-  historyRetentionDays: z3.number().int().positive().nullable().optional(),
+var runnerListSchema = z15.object({
+  capabilities: z15.record(z15.string(), z15.boolean()).optional(),
+  historyRetentionDays: z15.number().int().positive().nullable().optional(),
   /** Who the list was filtered for: a member sees their own and Team Runners, an admin every Runner. */
-  viewer: z3.object({ userId: z3.string(), admin: z3.boolean() }).optional(),
+  viewer: z15.object({ userId: z15.string(), admin: z15.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: 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(),
+  minimumRunnerVersion: z15.string().optional(),
+  runners: z15.array(runnerListEntrySchema),
+  profiles: z15.array(z15.object({
+    id: z15.string(),
+    label: z15.string(),
+    projectDir: z15.string(),
+    repositoryRequired: z15.boolean().optional(),
     /** Marketplace refs baked into the profile's image; absent when the profile declares none. */
-    workflows: z3.array(z3.string()).optional(),
-    workflowSources: z3.array(z3.string()).optional()
+    workflows: z15.array(z15.string()).optional(),
+    workflowSources: z15.array(z15.string()).optional()
   }))
 });
-var runnerDisconnectRequestSchema = z3.strictObject({ hubEpoch: z3.string() });
+var runnerDisconnectRequestSchema = z15.strictObject({ hubEpoch: z15.string() });
 var hubEpochRequestSchema = runnerDisconnectRequestSchema;
-var runnerDisconnectPreviewSchema = z3.object({
-  runnerId: id2,
-  name: z3.string().nullable(),
-  runs: z3.array(z3.object({
-    runId: id2,
-    label: z3.string().optional(),
+var runnerDisconnectPreviewSchema = z15.object({
+  runnerId: id14,
+  name: z15.string().nullable(),
+  runs: z15.array(z15.object({
+    runId: id14,
+    label: z15.string().optional(),
     /** Working: executing now. Parked: waiting for a person, Runner released. Queued: not started yet. */
-    state: z3.enum(["working", "parked", "queued"])
+    state: z15.enum(["working", "parked", "queued"])
   })),
-  hiddenRuns: z3.number().int().nonnegative()
+  hiddenRuns: z15.number().int().nonnegative()
 });
-var runnerDisconnectResponseSchema = z3.object({
-  disconnected: z3.literal(true),
+var runnerDisconnectResponseSchema = z15.object({
+  disconnected: z15.literal(true),
   /** How many Runs were Stopped with the reason `runner_disconnected`. */
-  stoppedRuns: z3.number().int().nonnegative()
+  stoppedRuns: z15.number().int().nonnegative()
 });
 var runnerAdoptRequestSchema = hubEpochRequestSchema;
 var connectStartRequestSchema = connectRedeemRequestSchema.omit({ code: true });
-var connectStartResponseSchema = z3.strictObject({
+var connectStartResponseSchema = z15.strictObject({
   /** The machine's secret for polling; never shown. */
-  deviceCode: z3.string().min(32).max(160),
+  deviceCode: z15.string().min(32).max(160),
   code: connectCodeSchema,
-  expiresAt: sequence,
-  intervalSec: z3.number().int().positive(),
+  expiresAt: sequence2,
+  intervalSec: z15.number().int().positive(),
   /** The web console page that approves `code`. */
-  verificationUrl: z3.string().url()
-});
-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 = z3.strictObject({
-  code: z3.string().min(8).max(16),
+  verificationUrl: z15.string().url()
+});
+var connectPollRequestSchema = z15.strictObject({ deviceCode: z15.string().min(32).max(160) });
+var connectPendingResponseSchema = z15.strictObject({
+  hostname: z15.string(),
+  os: z15.string(),
+  softwareVersion: z15.string(),
+  requestedAt: sequence2,
+  expiresAt: sequence2
+});
+var connectApproveRequestSchema = z15.strictObject({
+  code: z15.string().min(8).max(16),
   audience: audienceSchema,
-  hubEpoch: z3.string().optional()
+  hubEpoch: z15.string().optional()
 });
-var connectDenyRequestSchema = z3.strictObject({ code: z3.string().min(8).max(16) });
+var connectDenyRequestSchema = z15.strictObject({ code: z15.string().min(8).max(16) });
 export {
-  CALIBRATION_MIN_RUNS,
-  CALIBRATION_WINDOW_DAYS,
-  SIZE_CLASS_CAPS,
-  SIZE_CLASS_FORECASTS,
   abandonedConversationContinuationCapability,
-  attemptCost,
-  attemptForecast,
+  activeSessionControlCapability,
   audienceSchema,
-  budgetCheck,
   buildCloseReasonSchema,
-  calibrate,
-  calibrationSchema,
+  buildGatesCapability,
   canonicalJson,
+  capabilitySupport,
+  capabilitySupportSchema,
   checkpointPathSchema,
   checkpointSchema,
-  classOfCap,
   clientFrameSchema,
   commandSchema,
   connectAlreadyConnectedSchema,
@@ -920,6 +3546,7 @@ export {
   connectStartResponseSchema,
   controlRecordSchema,
   conversationContinuationCapability,
+  coordinationSupervisionCapability,
   defaultDeliveryWorkflow,
   delegationSchema,
   delegationTokenPrefix,
@@ -928,16 +3555,28 @@ export {
   deliveryStageSchema,
   deliveryTransitionSchema,
   deliveryWorkflowSchema,
-  forecastOfCap,
-  forecastOfClass,
+  gateModeSchema,
+  gateOverridesSchema,
   grantSchema,
   harnessReadinessSchema,
   harnessSchema,
+  harnessSessionControlSchema,
   historyRecordSchema,
   hubEpochRequestSchema,
+  inFlightToolSchema,
   installReference,
   installedWorkflowsSchema,
   interruptionSchema,
+  isWorkAttentionCommand,
+  isWorkDeploymentCommand,
+  isWorkDiscussionCommand,
+  isWorkEvidenceCommand,
+  isWorkImportCommand,
+  isWorkMembershipCommand,
+  isWorkPendingRelationCommand,
+  isWorkRelationCommand,
+  isWorkReservationCommand,
+  isWorkSourceCommand,
   orchestratorGuidanceCapability,
   permissionAnswerSchema,
   protocolVersion,
@@ -953,8 +3592,6 @@ export {
   runCloseReasonSchema,
   runDelegationCapability,
   runKeySchema,
-  runParentIntentSchema,
-  runParentSchema,
   runSpecSchema,
   runUsageCapability,
   runUsageSchema,
@@ -973,7 +3610,16 @@ export {
   sameWorkflow,
   scopeSchema,
   secretEnvironmentSchema,
-  sequence,
+  selectWorkPath,
+  sequence2 as sequence,
+  sessionCapabilityNameSchema,
+  sessionCapabilityNames,
+  sessionCapabilitySchema,
+  sessionControlCommandSchema,
+  sessionControlHistoryKind,
+  sessionControlObservationSchema,
+  sessionControlRejectionSchema,
+  supportedOperations,
   teamDefaultRequestSchema,
   teamDefaultSchema,
   trackerCommentSchema,
@@ -985,6 +3631,259 @@ export {
   trackerPlanSchema,
   trackerSnapshotSchema,
   trackerSourceSchema,
+  workActivityKindSchema,
+  workActivityPageSchema,
+  workActivitySchema,
+  workActorSchema,
+  workAttachmentAvailabilitySchema,
+  workAttachmentCheckPageSchema,
+  workAttachmentCheckSchema,
+  workAttachmentPageSchema,
+  workAttachmentSchema,
+  workAttentionActivityKindSchema,
+  workAttentionActivityPageSchema,
+  workAttentionActivitySchema,
+  workAttentionCommandResultSchema,
+  workAttentionCommandSchema,
+  workAttentionCommandTypes,
+  workAttentionErrorCodes,
+  workAttentionReasonSchema,
+  workAttentionRequestPageSchema,
+  workAttentionRequestSchema,
+  workAttentionResolutionSchema,
+  workAttentionRunRefSchema,
+  workAuthoritySchema,
+  workAutomationSchema,
+  workCandidateArtifactSchema,
+  workCandidateDeploymentSchema,
+  workCandidatePageSchema,
+  workCandidateQaProfileSchema,
+  workCandidateSchema,
+  workCandidateSelectionSchema,
+  workClientContract,
+  workClientContractHeader,
+  workClientContractMinimum,
+  workClientOperations,
+  workCommandResultSchema,
+  workCommandSchema,
+  workCommandVersion,
+  workCommentBodySchema,
+  workCommentEditSchema,
+  workCommentPageSchema,
+  workCommentRevisionPageSchema,
+  workCommentRevisionSchema,
+  workCommentSchema,
+  workDeliveryGateFindingSchema,
+  workDeliveryGateSchema,
+  workDeliveryMigrationMappingSchema,
+  workDeliveryMigrationPageSchema,
+  workDeliveryMigrationSchema,
+  workDeliveryRefSchema,
+  workDeliveryRequirementSchema,
+  workDeliverySlugSchema,
+  workDeliveryStatusCategorySchema,
+  workDeliveryStatusSchema,
+  workDeliveryTransitionSchema,
+  workDeliveryWorkflowDefinitionSchema,
+  workDeliveryWorkflowPageSchema,
+  workDeliveryWorkflowRevisionPageSchema,
+  workDeliveryWorkflowRevisionSchema,
+  workDeliveryWorkflowSchema,
+  workDependencyGateSchema,
+  workDependencyReasonSchema,
+  workDependencyRemedySchema,
+  workDeploymentActivityKindSchema,
+  workDeploymentActivityPageSchema,
+  workDeploymentActivitySchema,
+  workDeploymentCommandResultSchema,
+  workDeploymentCommandSchema,
+  workDeploymentCommandTypes,
+  workDeploymentErrorCodes,
+  workDeploymentLifecycleSchema,
+  workDeploymentPageSchema,
+  workDeploymentPurposeSchema,
+  workDeploymentSchema,
+  workDiscussionActivityKindSchema,
+  workDiscussionActivityPageSchema,
+  workDiscussionActivitySchema,
+  workDiscussionCommandResultSchema,
+  workDiscussionCommandSchema,
+  workDiscussionCommandTypes,
+  workDiscussionErrorCodes,
+  workDiscussionTombstoneSchema,
+  workErrorCodes,
+  workEvidenceActivityKindSchema,
+  workEvidenceActivityPageSchema,
+  workEvidenceActivitySchema,
+  workEvidenceApplicabilitySchema,
+  workEvidenceAssignmentSchema,
+  workEvidenceAutomationSchema,
+  workEvidenceCommandResultSchema,
+  workEvidenceCommandSchema,
+  workEvidenceCommandTypes,
+  workEvidenceDecisionSchema,
+  workEvidenceErrorCodes,
+  workEvidencePageSchema,
+  workEvidenceReferenceSchema,
+  workEvidenceSchema,
+  workEvidenceSourceAssertionSchema,
+  workExecutionBindingPageSchema,
+  workExecutionBindingSchema,
+  workExecutionPolicySchema,
+  workExecutionReservationPageSchema,
+  workExecutionReservationSchema,
+  workImportAttachmentSchema,
+  workImportBatchPageSchema,
+  workImportBatchSchema,
+  workImportBodyLimit,
+  workImportCollectionSchema,
+  workImportCollectionStateSchema,
+  workImportCollections,
+  workImportCommandResultSchema,
+  workImportCommandSchema,
+  workImportCommandTypes,
+  workImportCommentSchema,
+  workImportCommitSchema,
+  workImportCompletenessNoteSchema,
+  workImportCompletenessSchema,
+  workImportCompletenessSummarySchema,
+  workImportCompletionSchema,
+  workImportComponentPageSchema,
+  workImportComponentSchema,
+  workImportComponentStates,
+  workImportContainerSchema,
+  workImportDispositions,
+  workImportEnvelopeSchema,
+  workImportErrorCodes,
+  workImportField,
+  workImportFieldStates,
+  workImportFindingSchema,
+  workImportFormat,
+  workImportFormatVersion,
+  workImportGroupSchema,
+  workImportIssueSchema,
+  workImportItemPageSchema,
+  workImportItemSchema,
+  workImportKeySchema,
+  workImportLabelSchema,
+  workImportLimitSchema,
+  workImportLimits,
+  workImportMappingSchema,
+  workImportOutcomePageSchema,
+  workImportOutcomeSchema,
+  workImportOutcomes,
+  workImportPrincipalSchema,
+  workImportRelationSchema,
+  workImportSnapshotSchema,
+  workImportStatusSchema,
+  workImportTargetSchema,
+  workImportUnsupportedSchema,
+  workIssueAssigneePageSchema,
+  workIssueAssigneeSchema,
+  workIssueLabelPageSchema,
+  workIssueLabelSchema,
+  workIssueMembershipSchema,
+  workIssuePageSchema,
+  workIssueRelationKindSchema,
+  workIssueRelationPageSchema,
+  workIssueRelationSchema,
+  workIssueReservationSchema,
+  workIssueSchema,
+  workIssueTransitionsSchema,
+  workLabelColorSchema,
+  workLabelIssuePageSchema,
+  workLabelNameSchema,
+  workLabelPageSchema,
+  workLabelSchema,
+  workLegacyAliasSchema,
+  workLifecycleEventKindSchema,
+  workLifecycleEventPageSchema,
+  workLifecycleEventSchema,
+  workLifecycleSchema,
+  workLinkUrlSchema,
+  workManualAttentionReasonSchema,
+  workMembershipActivityKindSchema,
+  workMembershipActivityPageSchema,
+  workMembershipActivitySchema,
+  workMembershipCommandResultSchema,
+  workMembershipCommandSchema,
+  workMembershipCommandTypes,
+  workMembershipErrorCodes,
+  workMembershipRemovalSchema,
+  workOutstandingEffectSchema,
+  workPageLimits,
+  workPageSchema,
+  workPendingRelationActivityKindSchema,
+  workPendingRelationActivityPageSchema,
+  workPendingRelationActivitySchema,
+  workPendingRelationAttemptOutcomeSchema,
+  workPendingRelationCommandResultSchema,
+  workPendingRelationCommandSchema,
+  workPendingRelationCommandTypes,
+  workPendingRelationDispositionSchema,
+  workPendingRelationDispositions,
+  workPendingRelationErrorCodes,
+  workPendingRelationKindSchema,
+  workPendingRelationPageSchema,
+  workPendingRelationSchema,
+  workPlanPageSchema,
+  workPlanSchema,
+  workPrioritySchema,
+  workProductionTrailEntrySchema,
+  workProductionTrailPageSchema,
+  workRefSchema,
+  workRelationActivityKindSchema,
+  workRelationActivityPageSchema,
+  workRelationActivitySchema,
+  workRelationCommandResultSchema,
+  workRelationCommandSchema,
+  workRelationCommandTypes,
+  workRelationEndpointSchema,
+  workRelationErrorCodes,
+  workRelationRemovalSchema,
+  workReservationActivityKindSchema,
+  workReservationActivityPageSchema,
+  workReservationActivitySchema,
+  workReservationCommandResultSchema,
+  workReservationCommandSchema,
+  workReservationCommandTypes,
+  workReservationErrorCodes,
+  workReservationOwnerSchema,
+  workRunAttentionReasonSchema,
+  workScopeRevisionPageSchema,
+  workScopeRevisionRefSchema,
+  workScopeRevisionSchema,
+  workSourceActivityKindSchema,
+  workSourceActivityPageSchema,
+  workSourceActivitySchema,
+  workSourceAliasPageSchema,
+  workSourceAliasSchema,
+  workSourceAssociationPageSchema,
+  workSourceAssociationSchema,
+  workSourceCommandResultSchema,
+  workSourceCommandSchema,
+  workSourceCommandTypes,
+  workSourceContainerSchema,
+  workSourceErrorCodes,
+  workSourceKeyLifecycleSchema,
+  workSourceKeySchema,
+  workSourcePrincipalPageSchema,
+  workSourcePrincipalSchema,
+  workSourceReferencePageSchema,
+  workSourceReferenceSchema,
+  workSourceSpacePageSchema,
+  workSourceSpaceSchema,
+  workSourceTargetSchema,
+  workThreadOwnerSchema,
+  workThreadSchema,
+  workTranscriptHistorySchema,
+  workTranscriptLinkPageSchema,
+  workTranscriptLinkSchema,
+  workUnsatisfiedDependencySchema,
+  workVerificationAttemptPageSchema,
+  workVerificationAttemptSchema,
+  workVerificationOutcomeSchema,
+  workVerificationStandingSchema,
   workflowIdentitySchema,
   workflowInstallCapability,
   workflowName,