@h-rig/contracts 0.0.6-alpha.131 → 0.0.6-alpha.133

package/dist/src/drift.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+export declare const DriftKind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+export type DriftKind = typeof DriftKind.Type;
+export declare const DriftConfidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+export type DriftConfidence = typeof DriftConfidence.Type;
+export declare const DriftFinding: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+    readonly docPath: Schema.Trim;
+    readonly line: Schema.NullOr<Schema.Int>;
+    readonly reference: Schema.NullOr<Schema.Trim>;
+    readonly detail: Schema.String;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+}>;
+export type DriftFinding = typeof DriftFinding.Type;
+export declare const DriftReport: Schema.Struct<{
+    readonly generatedAt: Schema.String;
+    readonly scanned: Schema.Int;
+    readonly degraded: Schema.Boolean;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["deleted-reference", "stale-anchor", "semantic-mismatch", "issue-mismatch"]>;
+        readonly docPath: Schema.Trim;
+        readonly line: Schema.NullOr<Schema.Int>;
+        readonly reference: Schema.NullOr<Schema.Trim>;
+        readonly detail: Schema.String;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "low"]>;
+    }>>;
+}>;
+export type DriftReport = typeof DriftReport.Type;

package/dist/src/drift.js

@@ -0,0 +1,69 @@
+// @bun
+// packages/contracts/src/drift.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/drift.ts
+var DriftKind = Schema2.Literals([
+  "deleted-reference",
+  "stale-anchor",
+  "semantic-mismatch",
+  "issue-mismatch"
+]);
+var DriftConfidence = Schema2.Literals(["high", "medium", "low"]);
+var DriftFinding = Schema2.Struct({
+  kind: DriftKind,
+  docPath: TrimmedNonEmptyString,
+  line: Schema2.NullOr(PositiveInt),
+  reference: Schema2.NullOr(TrimmedNonEmptyString),
+  detail: Schema2.String,
+  confidence: DriftConfidence
+});
+var DriftReport = Schema2.Struct({
+  generatedAt: IsoDateTime,
+  scanned: NonNegativeInt,
+  degraded: Schema2.Boolean,
+  findings: Schema2.Array(DriftFinding)
+});
+export {
+  DriftReport,
+  DriftKind,
+  DriftFinding,
+  DriftConfidence
+};

package/dist/src/engine.js

@@ -139,6 +139,114 @@ var QueueEntry = Schema3.Struct({
   unblockCount: NonNegativeInt,
   position: NonNegativeInt
 });
+var DependencyEdgeType = Schema3.Literals(["blocks", "parent-child", "related"]);
+var DependencyEdge = Schema3.Struct({
+  fromTaskId: TaskId,
+  toTaskId: TaskId,
+  type: DependencyEdgeType
+});
+var BlockerClass = Schema3.Literals([
+  "not-blocked",
+  "task-blocked",
+  "human-decision",
+  "human-approval",
+  "external-input",
+  "unknown"
+]);
+var ActionRiskTier = Schema3.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
+var BlockerClassification = Schema3.Struct({
+  taskId: TaskId,
+  blockerClass: BlockerClass,
+  actionRiskTier: Schema3.NullOr(ActionRiskTier),
+  rationale: Schema3.String,
+  source: Schema3.Literals(["elimination", "label", "status", "llm"]),
+  autoApplied: Schema3.Boolean
+});
+var DependencyNode = Schema3.Struct({
+  taskId: TaskId,
+  title: TrimmedNonEmptyString,
+  status: TaskStatus,
+  priority: Schema3.NullOr(PositiveInt),
+  assignee: Schema3.NullOr(TrimmedNonEmptyString),
+  blockedBy: Schema3.Array(TaskId),
+  blocks: Schema3.Array(TaskId),
+  blockingDepth: NonNegativeInt,
+  blockerClass: Schema3.NullOr(BlockerClass),
+  actionRiskTier: Schema3.NullOr(ActionRiskTier),
+  epicKey: Schema3.NullOr(TrimmedNonEmptyString),
+  groupKey: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  externalId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  sourceIssueId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  scope: Schema3.optional(Schema3.Array(TrimmedNonEmptyString)),
+  validationKeys: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+var TaskGraphLane = Schema3.Struct({
+  key: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  x: Schema3.Number,
+  y: Schema3.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema3.String,
+  taskCount: NonNegativeInt
+});
+var TaskGraphStage = Schema3.Struct({
+  index: NonNegativeInt,
+  label: TrimmedNonEmptyString,
+  x: Schema3.Number,
+  width: NonNegativeInt
+});
+var TaskGraphNode = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  taskId: TaskId,
+  task: Schema3.optional(TaskSummary),
+  rowKey: TrimmedNonEmptyString,
+  rowLabel: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  stage: NonNegativeInt,
+  x: Schema3.Number,
+  y: Schema3.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema3.optional(Schema3.String),
+  taskCode: Schema3.optional(Schema3.NullOr(Schema3.String)),
+  strippedTitle: Schema3.optional(Schema3.String),
+  depsIn: Schema3.optional(NonNegativeInt),
+  depsOut: Schema3.optional(NonNegativeInt),
+  runCount: Schema3.optional(NonNegativeInt),
+  hasApprovals: Schema3.optional(Schema3.Boolean),
+  hasPendingUserInput: Schema3.optional(Schema3.Boolean),
+  hasRejectedReview: Schema3.optional(Schema3.Boolean),
+  hasFailedValidations: Schema3.optional(Schema3.Boolean),
+  artifactCount: Schema3.optional(NonNegativeInt)
+});
+var TaskGraphEdge = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  sourceId: TrimmedNonEmptyString,
+  targetId: TrimmedNonEmptyString,
+  color: Schema3.String,
+  kind: Schema3.Literals(["blocking", "parent-child"])
+});
+var TaskGraphLayout = Schema3.Struct({
+  lanes: Schema3.Array(TaskGraphLane),
+  stages: Schema3.Array(TaskGraphStage),
+  nodes: Schema3.Array(TaskGraphNode),
+  edges: Schema3.Array(TaskGraphEdge),
+  totalWidth: NonNegativeInt,
+  totalHeight: NonNegativeInt,
+  taskCount: NonNegativeInt
+});
+var DependencyGraphModel = Schema3.Struct({
+  graphId: GraphId,
+  nodes: Schema3.Array(DependencyNode),
+  edges: Schema3.Array(DependencyEdge),
+  layout: TaskGraphLayout,
+  cycles: Schema3.Array(Schema3.Array(TaskId)),
+  unresolvedRefs: Schema3.Array(TrimmedNonEmptyString),
+  degraded: Schema3.Boolean,
+  generatedAt: IsoDateTime
+});
 
 // packages/contracts/src/policy.ts
 import { Schema as Schema4 } from "effect";

package/dist/src/graph.d.ts

@@ -37,3 +37,287 @@ export declare const QueueEntry: Schema.Struct<{
     readonly position: Schema.Int;
 }>;
 export type QueueEntry = typeof QueueEntry.Type;
+export declare const DependencyEdgeType: Schema.Literals<readonly ["blocks", "parent-child", "related"]>;
+export type DependencyEdgeType = typeof DependencyEdgeType.Type;
+export declare const DependencyEdge: Schema.Struct<{
+    readonly fromTaskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly toTaskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly type: Schema.Literals<readonly ["blocks", "parent-child", "related"]>;
+}>;
+export type DependencyEdge = typeof DependencyEdge.Type;
+export declare const BlockerClass: Schema.Literals<readonly ["not-blocked", "task-blocked", "human-decision", "human-approval", "external-input", "unknown"]>;
+export type BlockerClass = typeof BlockerClass.Type;
+export declare const ActionRiskTier: Schema.Literals<readonly ["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]>;
+export type ActionRiskTier = typeof ActionRiskTier.Type;
+export declare const BlockerClassification: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly blockerClass: Schema.Literals<readonly ["not-blocked", "task-blocked", "human-decision", "human-approval", "external-input", "unknown"]>;
+    readonly actionRiskTier: Schema.NullOr<Schema.Literals<readonly ["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]>>;
+    readonly rationale: Schema.String;
+    readonly source: Schema.Literals<readonly ["elimination", "label", "status", "llm"]>;
+    readonly autoApplied: Schema.Boolean;
+}>;
+export type BlockerClassification = typeof BlockerClassification.Type;
+export declare const DependencyNode: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly title: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+    readonly priority: Schema.NullOr<Schema.Int>;
+    readonly assignee: Schema.NullOr<Schema.Trim>;
+    readonly blockedBy: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly blocks: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly blockingDepth: Schema.Int;
+    readonly blockerClass: Schema.NullOr<Schema.Literals<readonly ["not-blocked", "task-blocked", "human-decision", "human-approval", "external-input", "unknown"]>>;
+    readonly actionRiskTier: Schema.NullOr<Schema.Literals<readonly ["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]>>;
+    readonly epicKey: Schema.NullOr<Schema.Trim>;
+    readonly groupKey: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly externalId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly scope: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly validationKeys: Schema.optional<Schema.$Array<Schema.Trim>>;
+}>;
+export type DependencyNode = typeof DependencyNode.Type;
+export declare const TaskGraphLane: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly rowIndex: Schema.Int;
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly color: Schema.String;
+    readonly taskCount: Schema.Int;
+}>;
+export type TaskGraphLane = typeof TaskGraphLane.Type;
+export declare const TaskGraphStage: Schema.Struct<{
+    readonly index: Schema.Int;
+    readonly label: Schema.Trim;
+    readonly x: Schema.Number;
+    readonly width: Schema.Int;
+}>;
+export type TaskGraphStage = typeof TaskGraphStage.Type;
+export declare const TaskGraphNode: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly task: Schema.optional<Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "TaskId">;
+        readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+        readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+        readonly externalId: Schema.NullOr<Schema.Trim>;
+        readonly title: Schema.Trim;
+        readonly description: Schema.String;
+        readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+        readonly priority: Schema.NullOr<Schema.Int>;
+        readonly role: Schema.NullOr<Schema.Trim>;
+        readonly scope: Schema.$Array<Schema.Trim>;
+        readonly validationKeys: Schema.$Array<Schema.Trim>;
+        readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly metadata: Schema.Unknown;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly rowKey: Schema.Trim;
+    readonly rowLabel: Schema.Trim;
+    readonly rowIndex: Schema.Int;
+    readonly stage: Schema.Int;
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly color: Schema.optional<Schema.String>;
+    readonly taskCode: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly strippedTitle: Schema.optional<Schema.String>;
+    readonly depsIn: Schema.optional<Schema.Int>;
+    readonly depsOut: Schema.optional<Schema.Int>;
+    readonly runCount: Schema.optional<Schema.Int>;
+    readonly hasApprovals: Schema.optional<Schema.Boolean>;
+    readonly hasPendingUserInput: Schema.optional<Schema.Boolean>;
+    readonly hasRejectedReview: Schema.optional<Schema.Boolean>;
+    readonly hasFailedValidations: Schema.optional<Schema.Boolean>;
+    readonly artifactCount: Schema.optional<Schema.Int>;
+}>;
+export type TaskGraphNode = typeof TaskGraphNode.Type;
+export declare const TaskGraphEdge: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly sourceId: Schema.Trim;
+    readonly targetId: Schema.Trim;
+    readonly color: Schema.String;
+    readonly kind: Schema.Literals<readonly ["blocking", "parent-child"]>;
+}>;
+export type TaskGraphEdge = typeof TaskGraphEdge.Type;
+export declare const TaskGraphLayout: Schema.Struct<{
+    readonly lanes: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly label: Schema.Trim;
+        readonly rowIndex: Schema.Int;
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+        readonly width: Schema.Int;
+        readonly height: Schema.Int;
+        readonly color: Schema.String;
+        readonly taskCount: Schema.Int;
+    }>>;
+    readonly stages: Schema.$Array<Schema.Struct<{
+        readonly index: Schema.Int;
+        readonly label: Schema.Trim;
+        readonly x: Schema.Number;
+        readonly width: Schema.Int;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly task: Schema.optional<Schema.Struct<{
+            readonly id: Schema.brand<Schema.Trim, "TaskId">;
+            readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+            readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+            readonly externalId: Schema.NullOr<Schema.Trim>;
+            readonly title: Schema.Trim;
+            readonly description: Schema.String;
+            readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+            readonly priority: Schema.NullOr<Schema.Int>;
+            readonly role: Schema.NullOr<Schema.Trim>;
+            readonly scope: Schema.$Array<Schema.Trim>;
+            readonly validationKeys: Schema.$Array<Schema.Trim>;
+            readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+            readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+            readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+            readonly metadata: Schema.Unknown;
+            readonly createdAt: Schema.String;
+            readonly updatedAt: Schema.String;
+        }>>;
+        readonly rowKey: Schema.Trim;
+        readonly rowLabel: Schema.Trim;
+        readonly rowIndex: Schema.Int;
+        readonly stage: Schema.Int;
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+        readonly width: Schema.Int;
+        readonly height: Schema.Int;
+        readonly color: Schema.optional<Schema.String>;
+        readonly taskCode: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly strippedTitle: Schema.optional<Schema.String>;
+        readonly depsIn: Schema.optional<Schema.Int>;
+        readonly depsOut: Schema.optional<Schema.Int>;
+        readonly runCount: Schema.optional<Schema.Int>;
+        readonly hasApprovals: Schema.optional<Schema.Boolean>;
+        readonly hasPendingUserInput: Schema.optional<Schema.Boolean>;
+        readonly hasRejectedReview: Schema.optional<Schema.Boolean>;
+        readonly hasFailedValidations: Schema.optional<Schema.Boolean>;
+        readonly artifactCount: Schema.optional<Schema.Int>;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly sourceId: Schema.Trim;
+        readonly targetId: Schema.Trim;
+        readonly color: Schema.String;
+        readonly kind: Schema.Literals<readonly ["blocking", "parent-child"]>;
+    }>>;
+    readonly totalWidth: Schema.Int;
+    readonly totalHeight: Schema.Int;
+    readonly taskCount: Schema.Int;
+}>;
+export type TaskGraphLayout = typeof TaskGraphLayout.Type;
+export declare const DependencyGraphModel: Schema.Struct<{
+    readonly graphId: Schema.brand<Schema.Trim, "GraphId">;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly title: Schema.Trim;
+        readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+        readonly priority: Schema.NullOr<Schema.Int>;
+        readonly assignee: Schema.NullOr<Schema.Trim>;
+        readonly blockedBy: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+        readonly blocks: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+        readonly blockingDepth: Schema.Int;
+        readonly blockerClass: Schema.NullOr<Schema.Literals<readonly ["not-blocked", "task-blocked", "human-decision", "human-approval", "external-input", "unknown"]>>;
+        readonly actionRiskTier: Schema.NullOr<Schema.Literals<readonly ["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]>>;
+        readonly epicKey: Schema.NullOr<Schema.Trim>;
+        readonly groupKey: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly externalId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+        readonly scope: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly validationKeys: Schema.optional<Schema.$Array<Schema.Trim>>;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly fromTaskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly toTaskId: Schema.brand<Schema.Trim, "TaskId">;
+        readonly type: Schema.Literals<readonly ["blocks", "parent-child", "related"]>;
+    }>>;
+    readonly layout: Schema.Struct<{
+        readonly lanes: Schema.$Array<Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly label: Schema.Trim;
+            readonly rowIndex: Schema.Int;
+            readonly x: Schema.Number;
+            readonly y: Schema.Number;
+            readonly width: Schema.Int;
+            readonly height: Schema.Int;
+            readonly color: Schema.String;
+            readonly taskCount: Schema.Int;
+        }>>;
+        readonly stages: Schema.$Array<Schema.Struct<{
+            readonly index: Schema.Int;
+            readonly label: Schema.Trim;
+            readonly x: Schema.Number;
+            readonly width: Schema.Int;
+        }>>;
+        readonly nodes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.Trim;
+            readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+            readonly task: Schema.optional<Schema.Struct<{
+                readonly id: Schema.brand<Schema.Trim, "TaskId">;
+                readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+                readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+                readonly externalId: Schema.NullOr<Schema.Trim>;
+                readonly title: Schema.Trim;
+                readonly description: Schema.String;
+                readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+                readonly priority: Schema.NullOr<Schema.Int>;
+                readonly role: Schema.NullOr<Schema.Trim>;
+                readonly scope: Schema.$Array<Schema.Trim>;
+                readonly validationKeys: Schema.$Array<Schema.Trim>;
+                readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+                readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+                readonly metadata: Schema.Unknown;
+                readonly createdAt: Schema.String;
+                readonly updatedAt: Schema.String;
+            }>>;
+            readonly rowKey: Schema.Trim;
+            readonly rowLabel: Schema.Trim;
+            readonly rowIndex: Schema.Int;
+            readonly stage: Schema.Int;
+            readonly x: Schema.Number;
+            readonly y: Schema.Number;
+            readonly width: Schema.Int;
+            readonly height: Schema.Int;
+            readonly color: Schema.optional<Schema.String>;
+            readonly taskCode: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly strippedTitle: Schema.optional<Schema.String>;
+            readonly depsIn: Schema.optional<Schema.Int>;
+            readonly depsOut: Schema.optional<Schema.Int>;
+            readonly runCount: Schema.optional<Schema.Int>;
+            readonly hasApprovals: Schema.optional<Schema.Boolean>;
+            readonly hasPendingUserInput: Schema.optional<Schema.Boolean>;
+            readonly hasRejectedReview: Schema.optional<Schema.Boolean>;
+            readonly hasFailedValidations: Schema.optional<Schema.Boolean>;
+            readonly artifactCount: Schema.optional<Schema.Int>;
+        }>>;
+        readonly edges: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.Trim;
+            readonly sourceId: Schema.Trim;
+            readonly targetId: Schema.Trim;
+            readonly color: Schema.String;
+            readonly kind: Schema.Literals<readonly ["blocking", "parent-child"]>;
+        }>>;
+        readonly totalWidth: Schema.Int;
+        readonly totalHeight: Schema.Int;
+        readonly taskCount: Schema.Int;
+    }>;
+    readonly cycles: Schema.$Array<Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly unresolvedRefs: Schema.$Array<Schema.Trim>;
+    readonly degraded: Schema.Boolean;
+    readonly generatedAt: Schema.String;
+}>;
+export type DependencyGraphModel = typeof DependencyGraphModel.Type;

package/dist/src/graph.js

@@ -88,9 +88,129 @@ var QueueEntry = Schema2.Struct({
   unblockCount: NonNegativeInt,
   position: NonNegativeInt
 });
+var DependencyEdgeType = Schema2.Literals(["blocks", "parent-child", "related"]);
+var DependencyEdge = Schema2.Struct({
+  fromTaskId: TaskId,
+  toTaskId: TaskId,
+  type: DependencyEdgeType
+});
+var BlockerClass = Schema2.Literals([
+  "not-blocked",
+  "task-blocked",
+  "human-decision",
+  "human-approval",
+  "external-input",
+  "unknown"
+]);
+var ActionRiskTier = Schema2.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
+var BlockerClassification = Schema2.Struct({
+  taskId: TaskId,
+  blockerClass: BlockerClass,
+  actionRiskTier: Schema2.NullOr(ActionRiskTier),
+  rationale: Schema2.String,
+  source: Schema2.Literals(["elimination", "label", "status", "llm"]),
+  autoApplied: Schema2.Boolean
+});
+var DependencyNode = Schema2.Struct({
+  taskId: TaskId,
+  title: TrimmedNonEmptyString,
+  status: TaskStatus,
+  priority: Schema2.NullOr(PositiveInt),
+  assignee: Schema2.NullOr(TrimmedNonEmptyString),
+  blockedBy: Schema2.Array(TaskId),
+  blocks: Schema2.Array(TaskId),
+  blockingDepth: NonNegativeInt,
+  blockerClass: Schema2.NullOr(BlockerClass),
+  actionRiskTier: Schema2.NullOr(ActionRiskTier),
+  epicKey: Schema2.NullOr(TrimmedNonEmptyString),
+  groupKey: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  externalId: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  sourceIssueId: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  scope: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  validationKeys: Schema2.optional(Schema2.Array(TrimmedNonEmptyString))
+});
+var TaskGraphLane = Schema2.Struct({
+  key: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  x: Schema2.Number,
+  y: Schema2.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema2.String,
+  taskCount: NonNegativeInt
+});
+var TaskGraphStage = Schema2.Struct({
+  index: NonNegativeInt,
+  label: TrimmedNonEmptyString,
+  x: Schema2.Number,
+  width: NonNegativeInt
+});
+var TaskGraphNode = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  taskId: TaskId,
+  task: Schema2.optional(TaskSummary),
+  rowKey: TrimmedNonEmptyString,
+  rowLabel: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  stage: NonNegativeInt,
+  x: Schema2.Number,
+  y: Schema2.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema2.optional(Schema2.String),
+  taskCode: Schema2.optional(Schema2.NullOr(Schema2.String)),
+  strippedTitle: Schema2.optional(Schema2.String),
+  depsIn: Schema2.optional(NonNegativeInt),
+  depsOut: Schema2.optional(NonNegativeInt),
+  runCount: Schema2.optional(NonNegativeInt),
+  hasApprovals: Schema2.optional(Schema2.Boolean),
+  hasPendingUserInput: Schema2.optional(Schema2.Boolean),
+  hasRejectedReview: Schema2.optional(Schema2.Boolean),
+  hasFailedValidations: Schema2.optional(Schema2.Boolean),
+  artifactCount: Schema2.optional(NonNegativeInt)
+});
+var TaskGraphEdge = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  sourceId: TrimmedNonEmptyString,
+  targetId: TrimmedNonEmptyString,
+  color: Schema2.String,
+  kind: Schema2.Literals(["blocking", "parent-child"])
+});
+var TaskGraphLayout = Schema2.Struct({
+  lanes: Schema2.Array(TaskGraphLane),
+  stages: Schema2.Array(TaskGraphStage),
+  nodes: Schema2.Array(TaskGraphNode),
+  edges: Schema2.Array(TaskGraphEdge),
+  totalWidth: NonNegativeInt,
+  totalHeight: NonNegativeInt,
+  taskCount: NonNegativeInt
+});
+var DependencyGraphModel = Schema2.Struct({
+  graphId: GraphId,
+  nodes: Schema2.Array(DependencyNode),
+  edges: Schema2.Array(DependencyEdge),
+  layout: TaskGraphLayout,
+  cycles: Schema2.Array(Schema2.Array(TaskId)),
+  unresolvedRefs: Schema2.Array(TrimmedNonEmptyString),
+  degraded: Schema2.Boolean,
+  generatedAt: IsoDateTime
+});
 export {
   TaskSummary,
   TaskStatus,
+  TaskGraphStage,
+  TaskGraphNode,
+  TaskGraphLayout,
+  TaskGraphLane,
+  TaskGraphEdge,
   QueueEntry,
-  GraphSummary
+  GraphSummary,
+  DependencyNode,
+  DependencyGraphModel,
+  DependencyEdgeType,
+  DependencyEdge,
+  BlockerClassification,
+  BlockerClass,
+  ActionRiskTier
 };