@h-rig/contracts 0.0.6-alpha.154 → 0.0.6-alpha.156

package/dist/index.cjs

@@ -40,10 +40,18 @@ var __export = (target, all) => {
 // packages/contracts/src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  toTaskSummary: () => toTaskSummary,
+  toTaskDependencyProjection: () => toTaskDependencyProjection,
   timelineEntriesFromCustomEntries: () => timelineEntriesFromCustomEntries,
+  strictMergeHeadShaFromGate: () => strictMergeHeadShaFromGate,
   sessionIdFromSessionFile: () => sessionIdFromSessionFile,
-  reduceSupervisorJournal: () => reduceSupervisorJournal,
+  resolveTaskReference: () => resolveTaskReference,
   reduceRunJournal: () => reduceRunJournal,
+  readTaskSourceIssueId: () => readTaskSourceIssueId,
+  readTaskScope: () => readTaskScope,
+  readTaskMetadataStringList: () => readTaskMetadataStringList,
+  readTaskDependencyRefs: () => readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs: () => readTaskBlockingDependencyRefs,
   projectWorkflowEntries: () => projectWorkflowEntries,
   projectCollabWorkflowMarker: () => projectCollabWorkflowMarker,
   parseWorkflowTaskSelected: () => parseWorkflowTaskSelected,
@@ -57,14 +65,19 @@ __export(exports_src, {
   parseResumeSentinel: () => parseResumeSentinel,
   parsePauseSentinel: () => parsePauseSentinel,
   parseInboxResolutionSentinel: () => parseInboxResolutionSentinel,
+  normalizeTaskStatus: () => normalizeTaskStatus,
   normalizeRunStatusToken: () => normalizeRunStatusToken,
   latestTimelineEntriesFromCustomEntries: () => latestTimelineEntriesFromCustomEntries,
+  latestRunByTaskId: () => latestRunByTaskId,
   isTerminalRunStatus: () => isTerminalRunStatus,
+  isTaskTerminalStatus: () => isTaskTerminalStatus,
   isRunSessionCustomType: () => isRunSessionCustomType,
   isOperatorActiveRunStatus: () => isOperatorActiveRunStatus,
   isActiveRunStatus: () => isActiveRunStatus,
   helpCatalog: () => helpCatalog,
   foldRunSessionEntries: () => foldRunSessionEntries,
+  doctorLevelToStatus: () => doctorLevelToStatus,
+  disjointScope: () => disjointScope,
   decodeRunJournalEvent: () => decodeRunJournalEvent,
   createWorkflowTaskSelected: () => createWorkflowTaskSelected,
   createWorkflowTargetSelected: () => createWorkflowTargetSelected,
@@ -73,9 +86,13 @@ __export(exports_src, {
   createWorkflowOperatorNote: () => createWorkflowOperatorNote,
   createWorkflowInboxResolved: () => createWorkflowInboxResolved,
   createWorkflowInboxRequested: () => createWorkflowInboxRequested,
+  countDoctorFailures: () => countDoctorFailures,
+  computeTaskDependencyBadges: () => computeTaskDependencyBadges,
+  computeTaskBlockingDepths: () => computeTaskBlockingDepths,
   collectResolvedInboxRequests: () => collectResolvedInboxRequests,
   collectPendingInboxRequests: () => collectPendingInboxRequests,
   canTransitionRunStatus: () => canTransitionRunStatus,
+  buildTaskReferenceIndex: () => buildTaskReferenceIndex,
   buildStopSentinel: () => buildStopSentinel,
   buildResumeSentinel: () => buildResumeSentinel,
   buildPauseSentinel: () => buildPauseSentinel,
@@ -175,6 +192,7 @@ __export(exports_src, {
   TYPE_FOR_CUSTOM: () => TYPE_FOR_CUSTOM,
   TOP_LEVEL_SECTIONS: () => TOP_LEVEL_SECTIONS,
   TERMINAL_RUN_STATUSES: () => TERMINAL_RUN_STATUSES,
+  TASK_VERIFY_CAPABILITY_ID: () => TASK_VERIFY_CAPABILITY_ID,
   SupervisorStoppedEvent: () => SupervisorStoppedEvent,
   SupervisorStopReason: () => SupervisorStopReason,
   SupervisorStatus: () => SupervisorStatus,
@@ -204,6 +222,7 @@ __export(exports_src, {
   StageAllowResult: () => StageAllowResult,
   Stage: () => Stage,
   SkillRegistration: () => SkillRegistration,
+  SessionExtensionRegistration: () => SessionExtensionRegistration,
   ServiceFabricWorkspaceInput: () => ServiceFabricWorkspaceInput,
   ServiceFabricUpResult: () => ServiceFabricUpResult,
   ServiceFabricUpInput: () => ServiceFabricUpInput,
@@ -404,6 +423,7 @@ __export(exports_src, {
   RemoteConnectCommand: () => RemoteConnectCommand,
   RemoteAddIterationsCommand: () => RemoteAddIterationsCommand,
   RUN_STATUS_TRANSITIONS: () => RUN_STATUS_TRANSITIONS,
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID: () => RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
   RIG_WS_METHODS: () => RIG_WS_METHODS,
   RIG_WS_CHANNELS: () => RIG_WS_CHANNELS,
   RIG_WORKFLOW_TASK_SELECTED: () => RIG_WORKFLOW_TASK_SELECTED,
@@ -413,9 +433,11 @@ __export(exports_src, {
   RIG_WORKFLOW_OPERATOR_NOTE: () => RIG_WORKFLOW_OPERATOR_NOTE,
   RIG_WORKFLOW_INBOX_RESOLVED: () => RIG_WORKFLOW_INBOX_RESOLVED,
   RIG_WORKFLOW_INBOX_REQUESTED: () => RIG_WORKFLOW_INBOX_REQUESTED,
+  RIG_SUPERVISOR_PANEL_ID: () => RIG_SUPERVISOR_PANEL_ID,
   RIG_STOP_SENTINEL_END: () => RIG_STOP_SENTINEL_END,
   RIG_STOP_SENTINEL: () => RIG_STOP_SENTINEL,
   RIG_RUN_TIMELINE_ENTRY: () => RIG_RUN_TIMELINE_ENTRY,
+  RIG_RUN_STOP_PANEL_ACTION: () => RIG_RUN_STOP_PANEL_ACTION,
   RIG_RUN_STEERING: () => RIG_RUN_STEERING,
   RIG_RUN_STATUS_CHANGED: () => RIG_RUN_STATUS_CHANGED,
   RIG_RUN_STALL_DETECTED: () => RIG_RUN_STALL_DETECTED,
@@ -434,6 +456,7 @@ __export(exports_src, {
   RIG_PAUSE_SENTINEL: () => RIG_PAUSE_SENTINEL,
   RIG_INBOX_RESOLUTION_SENTINEL: () => RIG_INBOX_RESOLUTION_SENTINEL,
   RIG_CONTROL_SENTINEL_END: () => RIG_CONTROL_SENTINEL_END,
+  RIG_CAPABILITY_PANEL_SLOT: () => RIG_CAPABILITY_PANEL_SLOT,
   REASONING_EFFORT_OPTIONS_BY_PROVIDER: () => REASONING_EFFORT_OPTIONS_BY_PROVIDER,
   QueueEntry: () => QueueEntry,
   PullRequestConfig: () => PullRequestConfig,
@@ -485,7 +508,6 @@ __export(exports_src, {
   PolicyMode: () => PolicyMode,
   PolicyDecisionSummary: () => PolicyDecisionSummary,
   PolicyDecision: () => PolicyDecision,
-  PluginMeta: () => PluginMeta,
   PluginContributes: () => PluginContributes,
   PlanningConfig: () => PlanningConfig,
   PlanTask: () => PlanTask,
@@ -535,16 +557,18 @@ __export(exports_src, {
   ORCHESTRATION_WS_CHANNELS: () => ORCHESTRATION_WS_CHANNELS,
   OPERATOR_INACTIVE_RUN_STATUSES: () => OPERATOR_INACTIVE_RUN_STATUSES,
   NonNegativeInt: () => NonNegativeInt,
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY: () => NO_MATCH_RETRIEVAL_CANONICAL_KEY,
   MissingCapability: () => MissingCapability,
   MessageId: () => MessageId,
   MergeConfig: () => MergeConfig,
   MODEL_SLUG_ALIASES_BY_PROVIDER: () => MODEL_SLUG_ALIASES_BY_PROVIDER,
   MODEL_OPTIONS_BY_PROVIDER: () => MODEL_OPTIONS_BY_PROVIDER,
+  MEMORY_SERVICE_CAPABILITY_ID: () => MEMORY_SERVICE_CAPABILITY_ID,
   MAX_WHEN_EXPRESSION_DEPTH: () => MAX_WHEN_EXPRESSION_DEPTH,
   MAX_SCRIPT_ID_LENGTH: () => MAX_SCRIPT_ID_LENGTH,
   MAX_KEYBINDING_VALUE_LENGTH: () => MAX_KEYBINDING_VALUE_LENGTH,
   MAX_KEYBINDINGS_COUNT: () => MAX_KEYBINDINGS_COUNT,
-  LoadedPluginDescriptor: () => LoadedPluginDescriptor,
+  MANAGED_REPO_SERVICE_CAPABILITY_ID: () => MANAGED_REPO_SERVICE_CAPABILITY_ID,
   KeybindingsConfig: () => KeybindingsConfig,
   KeybindingWhenNode: () => KeybindingWhenNode,
   KeybindingShortcut: () => KeybindingShortcut,
@@ -561,6 +585,7 @@ __export(exports_src, {
   IsolationMode: () => IsolationMode,
   IsoDateTime: () => IsoDateTime,
   InsertStageMutation: () => InsertStageMutation,
+  ISOLATION_BACKEND_CAPABILITY_ID: () => ISOLATION_BACKEND_CAPABILITY_ID,
   HookToolInput: () => HookToolInput,
   HookResult: () => HookResult,
   HookRegistration: () => HookRegistration,
@@ -591,6 +616,7 @@ __export(exports_src, {
   GitCreateBranchInput: () => GitCreateBranchInput,
   GitCheckoutInput: () => GitCheckoutInput,
   GitBranch: () => GitBranch,
+  GITHUB_PROVIDER_CAPABILITY_ID: () => GITHUB_PROVIDER_CAPABILITY_ID,
   FunctionalRequirement: () => FunctionalRequirement,
   EventId: () => EventId,
   EpicRollup: () => EpicRollup,
@@ -627,6 +653,7 @@ __export(exports_src, {
   DependencyGraphModel: () => DependencyGraphModel,
   DependencyEdgeType: () => DependencyEdgeType,
   DependencyEdge: () => DependencyEdge,
+  DOCTOR_RUNNER_CAPABILITY_ID: () => DOCTOR_RUNNER_CAPABILITY_ID,
   DEFAULT_TERMINAL_ID: () => DEFAULT_TERMINAL_ID,
   DEFAULT_RUNTIME_MODE: () => DEFAULT_RUNTIME_MODE,
   DEFAULT_REASONING_EFFORT_BY_PROVIDER: () => DEFAULT_REASONING_EFFORT_BY_PROVIDER,
@@ -663,6 +690,7 @@ __export(exports_src, {
   CanonicalRequestType: () => CanonicalRequestType,
   CanonicalItemType: () => CanonicalItemType,
   CUSTOM_TYPE_FOR: () => CUSTOM_TYPE_FOR,
+  COMPLETION_VERIFICATION_CAPABILITY_ID: () => COMPLETION_VERIFICATION_CAPABILITY_ID,
   CODEX_REASONING_EFFORT_OPTIONS: () => CODEX_REASONING_EFFORT_OPTIONS,
   CLI_OUTPUT_VERSION: () => CLI_OUTPUT_VERSION,
   BootResultDescriptor: () => BootResultDescriptor,
@@ -670,6 +698,7 @@ __export(exports_src, {
   BlockerClassifierRegistration: () => BlockerClassifierRegistration,
   BlockerClassification: () => BlockerClassification,
   BlockerClass: () => BlockerClass,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID: () => BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
   AutomationConfig: () => AutomationConfig,
   AssistantDeliveryMode: () => AssistantDeliveryMode,
   AssigneeRollup: () => AssigneeRollup,
@@ -3207,6 +3236,19 @@ function latestTimelineEntriesFromCustomEntries(entries, limit) {
   timeline.reverse();
   return timeline;
 }
+// packages/contracts/src/run-record.ts
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
 // packages/contracts/src/run-status.ts
 var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
   "completed",
@@ -3312,19 +3354,6 @@ var CapabilityReplacementSpec = import_effect10.Schema.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = import_effect10.Schema.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: import_effect10.Schema.Array(CapabilityTag),
-  requires: import_effect10.Schema.optional(import_effect10.Schema.Array(CapabilityTag)),
-  replaces: import_effect10.Schema.optional(import_effect10.Schema.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = import_effect10.Schema.Struct({
-  meta: PluginMeta,
-  provides: import_effect10.Schema.Array(CapabilityTag),
-  contributes: import_effect10.Schema.Unknown,
-  runtime: import_effect10.Schema.Unknown
-});
 var KernelReplacementGrant = import_effect10.Schema.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: import_effect10.Schema.optional(TrimmedNonEmptyString),
@@ -3490,6 +3519,10 @@ var BlockerClassifierRegistration = import_effect11.Schema.Struct({
   description: import_effect11.Schema.optional(import_effect11.Schema.String),
   priority: import_effect11.Schema.optional(import_effect11.Schema.Number)
 });
+var SessionExtensionRegistration = import_effect11.Schema.Struct({
+  id: import_effect11.Schema.String,
+  description: import_effect11.Schema.optional(import_effect11.Schema.String)
+});
 var PluginContributes = import_effect11.Schema.Struct({
   validators: import_effect11.Schema.optional(import_effect11.Schema.Array(ValidatorRegistration)),
   hooks: import_effect11.Schema.optional(import_effect11.Schema.Array(HookRegistration)),
@@ -3503,7 +3536,8 @@ var PluginContributes = import_effect11.Schema.Struct({
   stageMutations: import_effect11.Schema.optional(import_effect11.Schema.Array(StageMutation)),
   capabilities: import_effect11.Schema.optional(import_effect11.Schema.Array(ProductCapabilityRegistration)),
   panels: import_effect11.Schema.optional(import_effect11.Schema.Array(PanelRegistration)),
-  blockerClassifiers: import_effect11.Schema.optional(import_effect11.Schema.Array(BlockerClassifierRegistration))
+  blockerClassifiers: import_effect11.Schema.optional(import_effect11.Schema.Array(BlockerClassifierRegistration)),
+  sessionExtensions: import_effect11.Schema.optional(import_effect11.Schema.Array(SessionExtensionRegistration))
 });
 var RigPlugin = import_effect11.Schema.Struct({
   name: import_effect11.Schema.String,
@@ -3651,79 +3685,6 @@ var SupervisorProjection = import_effect13.Schema.Struct({
   closures: import_effect13.Schema.Array(TaskClosureSummary),
   anomalies: import_effect13.Schema.Array(import_effect13.Schema.String)
 });
-function reduceSupervisorJournal(events) {
-  let processed = 0;
-  let succeeded = 0;
-  let failed = 0;
-  let skipped = 0;
-  let current = null;
-  let idleReason = null;
-  let stopReason = null;
-  let status = "running";
-  let plannedOrder = [];
-  let selectionPolicy = null;
-  const concurrency = null;
-  const closures = [];
-  const anomalies = [];
-  for (const event of events) {
-    switch (event.kind) {
-      case "supervisor.started":
-        status = "running";
-        break;
-      case "supervisor.selection-planned":
-        plannedOrder = [...event.taskIds];
-        selectionPolicy = event.policy;
-        break;
-      case "supervisor.dispatch-started":
-        break;
-      case "supervisor.dispatch-confirmed":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.dispatch":
-        current = { taskId: event.taskId, runId: event.runId };
-        break;
-      case "supervisor.outcome":
-        processed += 1;
-        if (event.failed) {
-          failed += 1;
-        } else {
-          succeeded += 1;
-        }
-        if (event.closure) {
-          closures.push(event.closure);
-        }
-        if (current?.runId === event.runId) {
-          current = null;
-        } else if (current !== null) {
-          anomalies.push(`outcome for ${event.runId} did not match current ${current.runId}`);
-        }
-        break;
-      case "supervisor.skipped":
-        processed += 1;
-        skipped += 1;
-        break;
-      case "supervisor.idle":
-        status = "idle";
-        idleReason = event.reason;
-        break;
-      case "supervisor.stopped":
-        status = "stopped";
-        stopReason = event.reason;
-        current = null;
-        break;
-      case "supervisor.finished":
-        status = "finished";
-        processed = event.processed;
-        succeeded = event.succeeded;
-        failed = event.failed;
-        skipped = event.skipped ?? skipped;
-        idleReason = event.idleReason;
-        current = null;
-        break;
-    }
-  }
-  return { status, processed, succeeded, failed, skipped, current, plannedOrder, selectionPolicy, concurrency, idleReason, stopReason, closures, anomalies };
-}
 
 // packages/contracts/src/config.ts
 var WorkspaceIsolation = import_effect14.Schema.Literals([
@@ -7032,7 +6993,7 @@ var PRIMARY_GROUPS = [
     name: "graph",
     summary: "Workspace dependency graph.",
     usage: ["rig graph [--json|--dot]"],
-    commands: [{ command: "[--json|--dot]", description: "Build the dependency graph through @rig/client and print summary, JSON, or DOT.", primary: true }],
+    commands: [{ command: "[--json|--dot]", description: "Build the workspace dependency graph and print summary, JSON, or DOT.", primary: true }],
     examples: ["rig graph", "rig graph --json", "rig graph --dot"]
   },
   {
@@ -7453,4 +7414,359 @@ var WorkspaceRollups = import_effect35.Schema.Struct({
   assignees: import_effect35.Schema.Array(AssigneeRollup),
   generatedAt: IsoDateTime
 });
+// packages/contracts/src/panel-protocol.ts
+var RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+var RIG_CAPABILITY_PANEL_SLOT = "capability";
+var RIG_SUPERVISOR_PANEL_ID = "supervisor";
+// packages/contracts/src/control-plane-types.ts
+function strictMergeHeadShaFromGate(result, prUrl, requireGreptile = true) {
+  if (!result.approved) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate is not approved.`);
+  }
+  if (result.evidence.prUrl !== prUrl) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate evidence belongs to ${result.evidence.prUrl}.`);
+  }
+  const headSha = result.evidence.headSha?.trim();
+  if (!headSha) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate did not provide a current head SHA.`);
+  }
+  if (!/^[0-9a-f]{40}$/i.test(headSha)) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate head is not a raw 40-character commit SHA.`);
+  }
+  if (requireGreptile) {
+    if (!result.evidence.greptile.fresh || result.evidence.greptile.currentHeadSha !== headSha) {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate approval is not tied to head ${headSha}.`);
+    }
+    if (result.evidence.greptile.mapping !== "score-5-of-5" && result.evidence.greptile.mapping !== "explicit-approved") {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate mapping is ${result.evidence.greptile.mapping}.`);
+    }
+  }
+  return headSha;
+}
+// packages/contracts/src/lifecycle-capabilities.ts
+var TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
+var COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+// packages/contracts/src/memory.ts
+var MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
+var NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+// packages/contracts/src/isolation.ts
+var ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
+// packages/contracts/src/managed-repos.ts
+var MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
+// packages/contracts/src/task-graph-primitives.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskId);
+    memo.set(taskId, depth);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+var TASK_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function metadataOf(task) {
+  return isObjectRecord(task.metadata) ? task.metadata : {};
+}
+function normalizeTaskStatus(status) {
+  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (token === "done")
+    return "completed";
+  if (token === "canceled")
+    return "cancelled";
+  return TASK_STATUSES.has(token) ? token : "unknown";
+}
+function toTaskDependencyProjection(task) {
+  const metadata = metadataOf(task);
+  return {
+    id: String(task.id),
+    title: stringValue(task.title),
+    status: normalizeTaskStatus(task.status),
+    priority: numberOrNull(task.priority),
+    metadata,
+    externalId: stringValue(task.externalId),
+    sourceIssueId: stringValue(task.sourceIssueId),
+    dependencies: stringArray(task.dependencies),
+    parentChildDeps: stringArray(task.parentChildDeps),
+    createdAt: stringValue(task.createdAt) ?? "",
+    updatedAt: stringValue(task.updatedAt) ?? "",
+    role: stringValue(task.role),
+    scope: stringArray(task.scope),
+    validationKeys: stringArray(task.validationKeys),
+    labels: stringArray(task.labels),
+    assignees: task.assignees,
+    assignedTo: task.assignedTo
+  };
+}
+function toTaskSummary(task, defaults = {}) {
+  const projection = toTaskDependencyProjection(task);
+  const metadata = metadataOf(task);
+  const createdAt = stringValue(task.createdAt) ?? "1970-01-01T00:00:00.000Z";
+  const updatedAt = stringValue(task.updatedAt) ?? createdAt;
+  return {
+    id: projection.id,
+    workspaceId: stringValue(task.workspaceId) ?? defaults.workspaceId ?? "workspace",
+    graphId: stringValue(task.graphId) ?? defaults.graphId ?? null,
+    externalId: projection.externalId,
+    title: projection.title ?? projection.id,
+    description: stringValue(task.description) ?? stringValue(task.body) ?? "",
+    status: projection.status,
+    priority: numberOrNull(task.priority),
+    role: projection.role,
+    scope: [...projection.scope ?? []],
+    validationKeys: [...projection.validationKeys ?? []],
+    ...projection.sourceIssueId ? { sourceIssueId: projection.sourceIssueId } : {},
+    dependencies: [...projection.dependencies ?? []],
+    parentChildDeps: [...projection.parentChildDeps ?? []],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+// packages/contracts/src/github.ts
+var GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+// packages/contracts/src/doctor.ts
+var DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
+function doctorLevelToStatus(level) {
+  return level === "ok" ? "pass" : level;
+}
+function countDoctorFailures(checks) {
+  return checks.filter((entry) => (entry.status ?? doctorLevelToStatus(entry.level ?? "warn")) === "fail").length;
+}
 })