@agimon-ai/doompi-task 0.0.1-alpha.8 → 0.0.1-alpha.80

package/dist/{store/types.d.cts → src/models/task.d.cts}

@@ -1,11 +1,11 @@
-import { InlineAgent } from "@agimon-ai/doompi-extension-contracts/subagent-tool";
-//#region src/store/types.d.ts
-type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
-declare const DELETED_STATUS: TaskStatus;
-type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
-type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+import { InlineAgent } from "@agimon-ai/doompi-core/delegation";
+//#region src/models/task.d.ts
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+export declare const DELETED_STATUS: TaskStatus;
+export type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
+export type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
 /** Terminal result of a delegated subagent run, copied off the delegation response. */
-interface DelegationResult {
+export interface DelegationResult {
   status: string;
   output?: string;
   outputPath?: string;
@@ -21,7 +21,7 @@ interface DelegationResult {
  * genuinely-running delegation from one orphaned by a harness crash, since the
  * child dies with its parent but the file survives.
  */
-interface TaskDelegation {
+export interface TaskDelegation {
   requestId: string;
   agent: string;
   state: DelegationState;
@@ -33,7 +33,7 @@ interface TaskDelegation {
   endedAt?: string;
   result?: DelegationResult;
 }
-interface Task {
+export interface Task {
   id: number;
   subject: string;
   description?: string;
@@ -46,15 +46,15 @@ interface Task {
   updatedAt?: string;
   delegation?: TaskDelegation;
 }
-declare const STORE_SCHEMA_VERSION = 1;
+export declare const STORE_SCHEMA_VERSION = 1;
 /** The complete on-disk document. `rev` increments on every committed write. */
-interface TaskDocument {
+export interface TaskDocument {
   version: number;
   rev: number;
   nextId: number;
   tasks: Task[];
 }
-declare function emptyDocument(): TaskDocument;
+export declare function emptyDocument(): TaskDocument;
 /**
  * A dependency target inside an upsert item: an existing task id, or the `ref`
  * of a task created earlier in the same call.
@@ -62,7 +62,7 @@ declare function emptyDocument(): TaskDocument;
  * Refs must start with a letter (see `REF_PATTERN`), so a ref is structurally
  * unconfusable with a stringified id and the discrimination is just `typeof`.
  */
-type DepToken = number | string;
+export type DepToken = number | string;
 /**
  * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
  *
@@ -71,7 +71,7 @@ type DepToken = number | string;
  * had. A field used against the wrong kind fails that item rather than being
  * silently ignored.
  */
-interface TaskItemMutation {
+export interface TaskItemMutation {
   id?: number;
   ref?: string;
   subject?: string;
@@ -91,7 +91,7 @@ interface TaskItemMutation {
  * `message` is unprefixed: the `item[N] failed:` framing belongs to the
  * formatter, because the Task Space overlay shows this text on its own.
  */
-type UpsertItemOutcome = {
+export type UpsertItemOutcome = {
   index: number;
   kind: 'created';
   id: number;
@@ -118,11 +118,28 @@ type UpsertItemOutcome = {
   ref?: string;
 };
 /** Which tasks an upsert touched, so renderResult names them instead of guessing. */
-interface UpsertSummary {
+export interface UpsertSummary {
   /** Ids of applied entries, in request order. A failed entry contributes nothing. */
   applied: number[];
   failed: number;
 }
+/** One task-to-agent handoff inside a native assignment batch. */
+export interface TaskAssignment {
+  id: number;
+  agent: string;
+  inlineAgent?: InlineAgent;
+  instructions?: string;
+  relevantFiles?: string[];
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+/** Which assignment entries started, so renderResult can show one consolidated batch. */
+export interface AssignmentSummary {
+  /** Ids of successful entries, in request order. A failed entry contributes nothing. */
+  assigned: number[];
+  failed: number;
+}
 /**
  * Open-shape input bag the reducer accepts. The index signature lets the
  * runtime pass a TypeBox `Static<typeof TaskParamsSchema>` through without
@@ -131,25 +148,19 @@ interface UpsertSummary {
  * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
  * `status` would be ambiguous once one call can carry many tasks.
  */
-interface TaskMutationParams {
+export interface TaskMutationParams {
   [key: string]: unknown;
   tasks?: TaskItemMutation[];
+  /** `assign` only: independent task-to-agent handoffs dispatched by one tool call. */
+  assignments?: TaskAssignment[];
   /** `list` filter only. To set a status, upsert the task by id. */
   status?: TaskStatus;
-  /** `get`, `delete`, `assign` and `cancel` only. */
+  /** `get`, `delete`, and `cancel` only. Assign ids live in `assignments[]`. */
   id?: number;
   includeDeleted?: boolean;
-  agent?: string;
-  inlineAgent?: InlineAgent;
-  instructions?: string;
-  /** `assign` only: the context pack the parent hands to the child. */
-  relevantFiles?: string[];
-  priorFindings?: string;
-  model?: string;
-  context?: 'fresh' | 'fork';
 }
 /** Snapshot returned under a tool result's `details` for renderResult. */
-interface TaskDetails {
+export interface TaskDetails {
   action: TaskAction;
   params: Record<string, unknown>;
   tasks: Task[];
@@ -157,9 +168,19 @@ interface TaskDetails {
   rev: number;
   error?: string;
   upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
 }
-/** A delegation is "live" while the owning run may still produce a response. */
-declare function isDelegationActive(task: Task): boolean;
+/**
+ * A delegation is "live" while the owning run may still produce a response.
+ *
+ * Takes the delegation shape rather than `Task` so the cockpit's `WebTask`,
+ * which carries the state as a plain string, answers the question the same way
+ * the store does.
+ */
+export declare function isDelegationActive(task: {
+  delegation?: {
+    state?: string;
+  };
+}): boolean;
 //#endregion
-export { DELETED_STATUS, DelegationResult, DelegationState, DepToken, STORE_SCHEMA_VERSION, Task, TaskAction, TaskDelegation, TaskDetails, TaskDocument, TaskItemMutation, TaskMutationParams, TaskStatus, UpsertItemOutcome, UpsertSummary, emptyDocument, isDelegationActive };
-//# sourceMappingURL=types.d.cts.map
+//# sourceMappingURL=task.d.cts.map

package/dist/src/models/task.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.cts","names":[],"sources":["../../../src/models/task.ts"],"mappings":";;YAUY;qBAEC,gBAAgB;YAEjB;YAEA;;iBAGK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;iBAUe;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA,SAAS;;iBAGM;EACf;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,WAAW;EACX;EACA;EACA,aAAa;;qBAGF;;iBAGI;EACf;EACA;EACA;EACA,OAAO;;wBAGO,iBAAiB;;;;;;;;YAWrB;;;;;;;;;iBAUK;EACf;EACA;EACA;EACA;EACA;EACA,SAAS;EACT,YAAY;EACZ,eAAe;EACf,kBAAkB;EAClB;EACA,WAAW;;;;;;;;;YAUD;EAEN;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;EAEA;EAAe;EAAiB;EAAY,YAAY;EAAY,UAAU;;EAC9E;EAAe;EAAmB;EAAY,QAAQ;;EACtD;EAAe;EAAgB;EAAiB;EAAa;;;iBAGlD;;EAEf;EACA;;;iBAIe;EACf;EACA;EACA,cAAc;EACd;EACA;EACA;EACA;EACA;;;iBAIe;;EAEf;EACA;;;;;;;;;;iBAWe;GACd;EACD,QAAQ;;EAER,cAAc;;EAEd,SAAS;;EAET;EACA;;;iBAIe;EACf,QAAQ;EACR,QAAQ;EACR,OAAO;EACP;EACA;EACA;EACA,SAAS;EACT,aAAa;;;;;;;;;wBAUC,mBAAmB;EAAQ;IAAe"}

package/dist/{store/types.d.mts → src/models/task.d.mts}

@@ -1,11 +1,11 @@
-import { InlineAgent } from "@agimon-ai/doompi-extension-contracts/subagent-tool";
-//#region src/store/types.d.ts
-type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
-declare const DELETED_STATUS: TaskStatus;
-type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
-type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+import { InlineAgent } from "@agimon-ai/doompi-core/delegation";
+//#region src/models/task.d.ts
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+export declare const DELETED_STATUS: TaskStatus;
+export type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
+export type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
 /** Terminal result of a delegated subagent run, copied off the delegation response. */
-interface DelegationResult {
+export interface DelegationResult {
   status: string;
   output?: string;
   outputPath?: string;
@@ -21,7 +21,7 @@ interface DelegationResult {
  * genuinely-running delegation from one orphaned by a harness crash, since the
  * child dies with its parent but the file survives.
  */
-interface TaskDelegation {
+export interface TaskDelegation {
   requestId: string;
   agent: string;
   state: DelegationState;
@@ -33,7 +33,7 @@ interface TaskDelegation {
   endedAt?: string;
   result?: DelegationResult;
 }
-interface Task {
+export interface Task {
   id: number;
   subject: string;
   description?: string;
@@ -46,15 +46,15 @@ interface Task {
   updatedAt?: string;
   delegation?: TaskDelegation;
 }
-declare const STORE_SCHEMA_VERSION = 1;
+export declare const STORE_SCHEMA_VERSION = 1;
 /** The complete on-disk document. `rev` increments on every committed write. */
-interface TaskDocument {
+export interface TaskDocument {
   version: number;
   rev: number;
   nextId: number;
   tasks: Task[];
 }
-declare function emptyDocument(): TaskDocument;
+export declare function emptyDocument(): TaskDocument;
 /**
  * A dependency target inside an upsert item: an existing task id, or the `ref`
  * of a task created earlier in the same call.
@@ -62,7 +62,7 @@ declare function emptyDocument(): TaskDocument;
  * Refs must start with a letter (see `REF_PATTERN`), so a ref is structurally
  * unconfusable with a stringified id and the discrimination is just `typeof`.
  */
-type DepToken = number | string;
+export type DepToken = number | string;
 /**
  * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
  *
@@ -71,7 +71,7 @@ type DepToken = number | string;
  * had. A field used against the wrong kind fails that item rather than being
  * silently ignored.
  */
-interface TaskItemMutation {
+export interface TaskItemMutation {
   id?: number;
   ref?: string;
   subject?: string;
@@ -91,7 +91,7 @@ interface TaskItemMutation {
  * `message` is unprefixed: the `item[N] failed:` framing belongs to the
  * formatter, because the Task Space overlay shows this text on its own.
  */
-type UpsertItemOutcome = {
+export type UpsertItemOutcome = {
   index: number;
   kind: 'created';
   id: number;
@@ -118,11 +118,28 @@ type UpsertItemOutcome = {
   ref?: string;
 };
 /** Which tasks an upsert touched, so renderResult names them instead of guessing. */
-interface UpsertSummary {
+export interface UpsertSummary {
   /** Ids of applied entries, in request order. A failed entry contributes nothing. */
   applied: number[];
   failed: number;
 }
+/** One task-to-agent handoff inside a native assignment batch. */
+export interface TaskAssignment {
+  id: number;
+  agent: string;
+  inlineAgent?: InlineAgent;
+  instructions?: string;
+  relevantFiles?: string[];
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+/** Which assignment entries started, so renderResult can show one consolidated batch. */
+export interface AssignmentSummary {
+  /** Ids of successful entries, in request order. A failed entry contributes nothing. */
+  assigned: number[];
+  failed: number;
+}
 /**
  * Open-shape input bag the reducer accepts. The index signature lets the
  * runtime pass a TypeBox `Static<typeof TaskParamsSchema>` through without
@@ -131,25 +148,19 @@ interface UpsertSummary {
  * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
  * `status` would be ambiguous once one call can carry many tasks.
  */
-interface TaskMutationParams {
+export interface TaskMutationParams {
   [key: string]: unknown;
   tasks?: TaskItemMutation[];
+  /** `assign` only: independent task-to-agent handoffs dispatched by one tool call. */
+  assignments?: TaskAssignment[];
   /** `list` filter only. To set a status, upsert the task by id. */
   status?: TaskStatus;
-  /** `get`, `delete`, `assign` and `cancel` only. */
+  /** `get`, `delete`, and `cancel` only. Assign ids live in `assignments[]`. */
   id?: number;
   includeDeleted?: boolean;
-  agent?: string;
-  inlineAgent?: InlineAgent;
-  instructions?: string;
-  /** `assign` only: the context pack the parent hands to the child. */
-  relevantFiles?: string[];
-  priorFindings?: string;
-  model?: string;
-  context?: 'fresh' | 'fork';
 }
 /** Snapshot returned under a tool result's `details` for renderResult. */
-interface TaskDetails {
+export interface TaskDetails {
   action: TaskAction;
   params: Record<string, unknown>;
   tasks: Task[];
@@ -157,9 +168,19 @@ interface TaskDetails {
   rev: number;
   error?: string;
   upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
 }
-/** A delegation is "live" while the owning run may still produce a response. */
-declare function isDelegationActive(task: Task): boolean;
+/**
+ * A delegation is "live" while the owning run may still produce a response.
+ *
+ * Takes the delegation shape rather than `Task` so the cockpit's `WebTask`,
+ * which carries the state as a plain string, answers the question the same way
+ * the store does.
+ */
+export declare function isDelegationActive(task: {
+  delegation?: {
+    state?: string;
+  };
+}): boolean;
 //#endregion
-export { DELETED_STATUS, DelegationResult, DelegationState, DepToken, STORE_SCHEMA_VERSION, Task, TaskAction, TaskDelegation, TaskDetails, TaskDocument, TaskItemMutation, TaskMutationParams, TaskStatus, UpsertItemOutcome, UpsertSummary, emptyDocument, isDelegationActive };
-//# sourceMappingURL=types.d.mts.map
+//# sourceMappingURL=task.d.mts.map

package/dist/src/models/task.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.mts","names":[],"sources":["../../../src/models/task.ts"],"mappings":";;YAUY;qBAEC,gBAAgB;YAEjB;YAEA;;iBAGK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;iBAUe;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA,SAAS;;iBAGM;EACf;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,WAAW;EACX;EACA;EACA,aAAa;;qBAGF;;iBAGI;EACf;EACA;EACA;EACA,OAAO;;wBAGO,iBAAiB;;;;;;;;YAWrB;;;;;;;;;iBAUK;EACf;EACA;EACA;EACA;EACA;EACA,SAAS;EACT,YAAY;EACZ,eAAe;EACf,kBAAkB;EAClB;EACA,WAAW;;;;;;;;;YAUD;EAEN;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;EAEA;EAAe;EAAiB;EAAY,YAAY;EAAY,UAAU;;EAC9E;EAAe;EAAmB;EAAY,QAAQ;;EACtD;EAAe;EAAgB;EAAiB;EAAa;;;iBAGlD;;EAEf;EACA;;;iBAIe;EACf;EACA;EACA,cAAc;EACd;EACA;EACA;EACA;EACA;;;iBAIe;;EAEf;EACA;;;;;;;;;;iBAWe;GACd;EACD,QAAQ;;EAER,cAAc;;EAEd,SAAS;;EAET;EACA;;;iBAIe;EACf,QAAQ;EACR,QAAQ;EACR,OAAO;EACP;EACA;EACA;EACA,SAAS;EACT,aAAa;;;;;;;;;wBAUC,mBAAmB;EAAQ;IAAe"}

package/dist/src/models/task.mjs

@@ -0,0 +1,26 @@
+//#region src/models/task.ts
+const DELETED_STATUS = "deleted";
+const STORE_SCHEMA_VERSION = 1;
+function emptyDocument() {
+	return {
+		version: 1,
+		rev: 0,
+		nextId: 1,
+		tasks: []
+	};
+}
+/**
+* A delegation is "live" while the owning run may still produce a response.
+*
+* Takes the delegation shape rather than `Task` so the cockpit's `WebTask`,
+* which carries the state as a plain string, answers the question the same way
+* the store does.
+*/
+function isDelegationActive(task) {
+	const state = task.delegation?.state;
+	return state === "requested" || state === "running";
+}
+//#endregion
+export { DELETED_STATUS, STORE_SCHEMA_VERSION, emptyDocument, isDelegationActive };
+
+//# sourceMappingURL=task.mjs.map

package/dist/src/models/task.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.mjs","names":[],"sources":["../../../src/models/task.ts"],"sourcesContent":["/**\n * Domain types for the file-backed task store.\n *\n * The on-disk document is the durable source of truth (unlike rpiv-todo, which\n * replayed state from the transcript). Every field here round-trips through\n * JSON, so nothing may hold non-serializable values.\n */\n\nimport type { InlineAgent } from '@agimon-ai/doompi-core/delegation';\n\nexport type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';\n\nexport const DELETED_STATUS: TaskStatus = 'deleted';\n\nexport type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';\n\nexport type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';\n\n/** Terminal result of a delegated subagent run, copied off the delegation response. */\nexport interface DelegationResult {\n  status: string;\n  output?: string;\n  outputPath?: string;\n  sessionFile?: string;\n  error?: string;\n  durationMs?: number;\n  toolCount?: number;\n}\n\n/**\n * Delegation bookkeeping attached to a task that was handed to a subagent.\n *\n * `pid` is the harness process that owns the run: it is the only way to tell an\n * genuinely-running delegation from one orphaned by a harness crash, since the\n * child dies with its parent but the file survives.\n */\nexport interface TaskDelegation {\n  requestId: string;\n  agent: string;\n  state: DelegationState;\n  sessionId?: string;\n  pid?: number;\n  runId?: string;\n  model?: string;\n  startedAt?: string;\n  endedAt?: string;\n  result?: DelegationResult;\n}\n\nexport interface Task {\n  id: number;\n  subject: string;\n  description?: string;\n  activeForm?: string;\n  status: TaskStatus;\n  blockedBy?: number[];\n  owner?: string;\n  metadata?: Record<string, unknown>;\n  createdAt?: string;\n  updatedAt?: string;\n  delegation?: TaskDelegation;\n}\n\nexport const STORE_SCHEMA_VERSION = 1;\n\n/** The complete on-disk document. `rev` increments on every committed write. */\nexport interface TaskDocument {\n  version: number;\n  rev: number;\n  nextId: number;\n  tasks: Task[];\n}\n\nexport function emptyDocument(): TaskDocument {\n  return { version: STORE_SCHEMA_VERSION, rev: 0, nextId: 1, tasks: [] };\n}\n\n/**\n * A dependency target inside an upsert item: an existing task id, or the `ref`\n * of a task created earlier in the same call.\n *\n * Refs must start with a letter (see `REF_PATTERN`), so a ref is structurally\n * unconfusable with a stringified id and the discrimination is just `typeof`.\n */\nexport type DepToken = number | string;\n\n/**\n * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.\n *\n * `blockedBy` (absolute set) is create-only and `addBlockedBy`/`removeBlockedBy`\n * (additive merge) are update-only, matching the split the two former actions\n * had. A field used against the wrong kind fails that item rather than being\n * silently ignored.\n */\nexport interface TaskItemMutation {\n  id?: number;\n  ref?: string;\n  subject?: string;\n  description?: string;\n  activeForm?: string;\n  status?: TaskStatus;\n  blockedBy?: DepToken[];\n  addBlockedBy?: DepToken[];\n  removeBlockedBy?: DepToken[];\n  owner?: string;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * What one upsert item did. `index` is its position in the request array, so a\n * model reading a partial result can tell which entries still need resending.\n *\n * `message` is unprefixed: the `item[N] failed:` framing belongs to the\n * formatter, because the Task Space overlay shows this text on its own.\n */\nexport type UpsertItemOutcome =\n  | {\n      index: number;\n      kind: 'created';\n      id: number;\n      subject: string;\n      status: TaskStatus;\n      ref?: string;\n      blockedBy?: number[];\n    }\n  | { index: number; kind: 'updated'; id: number; fromStatus: TaskStatus; toStatus: TaskStatus }\n  | { index: number; kind: 'unchanged'; id: number; status: TaskStatus }\n  | { index: number; kind: 'failed'; message: string; id?: number; ref?: string };\n\n/** Which tasks an upsert touched, so renderResult names them instead of guessing. */\nexport interface UpsertSummary {\n  /** Ids of applied entries, in request order. A failed entry contributes nothing. */\n  applied: number[];\n  failed: number;\n}\n\n/** One task-to-agent handoff inside a native assignment batch. */\nexport interface TaskAssignment {\n  id: number;\n  agent: string;\n  inlineAgent?: InlineAgent;\n  instructions?: string;\n  relevantFiles?: string[];\n  priorFindings?: string;\n  model?: string;\n  context?: 'fresh' | 'fork';\n}\n\n/** Which assignment entries started, so renderResult can show one consolidated batch. */\nexport interface AssignmentSummary {\n  /** Ids of successful entries, in request order. A failed entry contributes nothing. */\n  assigned: number[];\n  failed: number;\n}\n\n/**\n * Open-shape input bag the reducer accepts. The index signature lets the\n * runtime pass a TypeBox `Static<typeof TaskParamsSchema>` through without\n * casting each field.\n *\n * Per-task fields live on `tasks[]`, not here: a top-level `subject` or\n * `status` would be ambiguous once one call can carry many tasks.\n */\nexport interface TaskMutationParams {\n  [key: string]: unknown;\n  tasks?: TaskItemMutation[];\n  /** `assign` only: independent task-to-agent handoffs dispatched by one tool call. */\n  assignments?: TaskAssignment[];\n  /** `list` filter only. To set a status, upsert the task by id. */\n  status?: TaskStatus;\n  /** `get`, `delete`, and `cancel` only. Assign ids live in `assignments[]`. */\n  id?: number;\n  includeDeleted?: boolean;\n}\n\n/** Snapshot returned under a tool result's `details` for renderResult. */\nexport interface TaskDetails {\n  action: TaskAction;\n  params: Record<string, unknown>;\n  tasks: Task[];\n  nextId: number;\n  rev: number;\n  error?: string;\n  upsert?: UpsertSummary;\n  assignment?: AssignmentSummary;\n}\n\n/**\n * A delegation is \"live\" while the owning run may still produce a response.\n *\n * Takes the delegation shape rather than `Task` so the cockpit's `WebTask`,\n * which carries the state as a plain string, answers the question the same way\n * the store does.\n */\nexport function isDelegationActive(task: { delegation?: { state?: string } }): boolean {\n  const state = task.delegation?.state;\n  return state === 'requested' || state === 'running';\n}\n"],"mappings":";AAYA,MAAa,iBAA6B;AAmD1C,MAAa,uBAAuB;AAUpC,SAAgB,gBAA8B;CAC5C,OAAO;EAAE,SAAA;EAA+B,KAAK;EAAG,QAAQ;EAAG,OAAO,CAAC;CAAE;AACvE;;;;;;;;AAuHA,SAAgB,mBAAmB,MAAoD;CACrF,MAAM,QAAQ,KAAK,YAAY;CAC/B,OAAO,UAAU,eAAe,UAAU;AAC5C"}

package/dist/src/models/taskGraph.cjs

@@ -0,0 +1,67 @@
+//#region src/models/taskGraph.ts
+const COMPLETED_STATUS = "completed";
+const DELETED_STATUS = "deleted";
+/** True when a non-empty list has no visible work left to finish. */
+function isTaskListComplete(taskList) {
+	const visible = taskList.filter((task) => task.status !== DELETED_STATUS);
+	return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);
+}
+/**
+* Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?
+*
+* Takes the proposed additions explicitly so the reducer can ask the question
+* before mutating anything.
+*/
+function detectCycle(taskList, taskId, newBlockedBy) {
+	const edges = /* @__PURE__ */ new Map();
+	for (const task of taskList) if (task.id === taskId) edges.set(task.id, [.../* @__PURE__ */ new Set([...task.blockedBy ?? [], ...newBlockedBy])]);
+	else edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const hasCycleFrom = (node) => {
+		if (visiting.has(node)) return true;
+		if (visited.has(node)) return false;
+		visiting.add(node);
+		for (const next of edges.get(node) ?? []) if (hasCycleFrom(next)) return true;
+		visiting.delete(node);
+		visited.add(node);
+		return false;
+	};
+	for (const node of edges.keys()) if (hasCycleFrom(node)) return true;
+	return false;
+}
+/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
+function deriveBlocks(taskList) {
+	const blocks = /* @__PURE__ */ new Map();
+	for (const task of taskList) for (const dep of task.blockedBy ?? []) {
+		const dependents = blocks.get(dep) ?? [];
+		dependents.push(task.id);
+		blocks.set(dep, dependents);
+	}
+	return blocks;
+}
+/**
+* Blocking dependencies of a task that are not yet resolved.
+*
+* `completed` clears a dependency; `failed` deliberately does not, so a failed
+* delegation keeps its dependents blocked instead of silently releasing work
+* that was never actually finished.
+*/
+function unresolvedBlockers(taskList, task) {
+	return (task.blockedBy ?? []).filter((dep) => {
+		const blocker = taskList.find((candidate) => candidate.id === dep);
+		if (!blocker) return false;
+		return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;
+	});
+}
+function isBlocked(taskList, task) {
+	return unresolvedBlockers(taskList, task).length > 0;
+}
+//#endregion
+exports.deriveBlocks = deriveBlocks;
+exports.detectCycle = detectCycle;
+exports.isBlocked = isBlocked;
+exports.isTaskListComplete = isTaskListComplete;
+exports.unresolvedBlockers = unresolvedBlockers;
+
+//# sourceMappingURL=taskGraph.cjs.map

package/dist/{store → src/models}/taskGraph.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"taskGraph.cjs","names":[],"sources":["../../src/store/taskGraph.ts"],"sourcesContent":["import type { Task } from './types.ts';\n\nconst COMPLETED_STATUS: Task['status'] = 'completed';\nconst DELETED_STATUS: Task['status'] = 'deleted';\n\n/** True when a non-empty list has no visible work left to finish. */\nexport function isTaskListComplete(taskList: readonly Task[]): boolean {\n  const visible = taskList.filter((task) => task.status !== DELETED_STATUS);\n  return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);\n}\n\n/**\n * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?\n *\n * Takes the proposed additions explicitly so the reducer can ask the question\n * before mutating anything.\n */\nexport function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {\n  const edges = new Map<number, number[]>();\n  for (const task of taskList) {\n    if (task.id === taskId) {\n      edges.set(task.id, [...new Set([...(task.blockedBy ?? []), ...newBlockedBy])]);\n    } else {\n      edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);\n    }\n  }\n\n  const visiting = new Set<number>();\n  const visited = new Set<number>();\n  const hasCycleFrom = (node: number): boolean => {\n    if (visiting.has(node)) return true;\n    if (visited.has(node)) return false;\n    visiting.add(node);\n    for (const next of edges.get(node) ?? []) {\n      if (hasCycleFrom(next)) return true;\n    }\n    visiting.delete(node);\n    visited.add(node);\n    return false;\n  };\n\n  for (const node of edges.keys()) {\n    if (hasCycleFrom(node)) return true;\n  }\n  return false;\n}\n\n/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */\nexport function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {\n  const blocks = new Map<number, number[]>();\n  for (const task of taskList) {\n    for (const dep of task.blockedBy ?? []) {\n      const dependents = blocks.get(dep) ?? [];\n      dependents.push(task.id);\n      blocks.set(dep, dependents);\n    }\n  }\n  return blocks;\n}\n\n/**\n * Blocking dependencies of a task that are not yet resolved.\n *\n * `completed` clears a dependency; `failed` deliberately does not, so a failed\n * delegation keeps its dependents blocked instead of silently releasing work\n * that was never actually finished.\n */\nexport function unresolvedBlockers(taskList: readonly Task[], task: Task): number[] {\n  return (task.blockedBy ?? []).filter((dep) => {\n    const blocker = taskList.find((candidate) => candidate.id === dep);\n    if (!blocker) return false;\n    return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;\n  });\n}\n\nexport function isBlocked(taskList: readonly Task[], task: Task): boolean {\n  return unresolvedBlockers(taskList, task).length > 0;\n}\n"],"mappings":"mEAEA,MAAM,EAAmC,YACnC,EAAiC,UAGvC,SAAgB,EAAmB,EAAoC,CACrE,IAAM,EAAU,EAAS,OAAQ,GAAS,EAAK,SAAW,CAAc,EACxE,OAAO,EAAQ,OAAS,GAAK,EAAQ,MAAO,GAAS,EAAK,SAAW,CAAgB,CACvF,CAQA,SAAgB,EAAY,EAA2B,EAAgB,EAA0C,CAC/G,IAAM,EAAQ,IAAI,IAClB,IAAK,IAAM,KAAQ,EACb,EAAK,KAAO,EACd,EAAM,IAAI,EAAK,GAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAI,EAAK,WAAa,CAAC,EAAI,GAAG,CAAY,CAAC,CAAC,CAAC,EAE7E,EAAM,IAAI,EAAK,GAAI,EAAK,UAAY,CAAC,GAAG,EAAK,SAAS,EAAI,CAAC,CAAC,EAIhE,IAAM,EAAW,IAAI,IACf,EAAU,IAAI,IACd,EAAgB,GAA0B,CAC9C,GAAI,EAAS,IAAI,CAAI,EAAG,MAAO,GAC/B,GAAI,EAAQ,IAAI,CAAI,EAAG,MAAO,GAC9B,EAAS,IAAI,CAAI,EACjB,IAAK,IAAM,KAAQ,EAAM,IAAI,CAAI,GAAK,CAAC,EACrC,GAAI,EAAa,CAAI,EAAG,MAAO,GAIjC,OAFA,EAAS,OAAO,CAAI,EACpB,EAAQ,IAAI,CAAI,EACT,EACT,EAEA,IAAK,IAAM,KAAQ,EAAM,KAAK,EAC5B,GAAI,EAAa,CAAI,EAAG,MAAO,GAEjC,MAAO,EACT,CAGA,SAAgB,EAAa,EAAkD,CAC7E,IAAM,EAAS,IAAI,IACnB,IAAK,IAAM,KAAQ,EACjB,IAAK,IAAM,KAAO,EAAK,WAAa,CAAC,EAAG,CACtC,IAAM,EAAa,EAAO,IAAI,CAAG,GAAK,CAAC,EACvC,EAAW,KAAK,EAAK,EAAE,EACvB,EAAO,IAAI,EAAK,CAAU,CAC5B,CAEF,OAAO,CACT,CASA,SAAgB,EAAmB,EAA2B,EAAsB,CAClF,OAAQ,EAAK,WAAa,CAAC,EAAA,CAAG,OAAQ,GAAQ,CAC5C,IAAM,EAAU,EAAS,KAAM,GAAc,EAAU,KAAO,CAAG,EAEjE,OADK,EACE,EAAQ,SAAW,GAAoB,EAAQ,SAAW,EAD5C,EAEvB,CAAC,CACH,CAEA,SAAgB,EAAU,EAA2B,EAAqB,CACxE,OAAO,EAAmB,EAAU,CAAI,CAAC,CAAC,OAAS,CACrD"}
+{"version":3,"file":"taskGraph.cjs","names":[],"sources":["../../../src/models/taskGraph.ts"],"sourcesContent":["import type { Task } from './task';\n\nconst COMPLETED_STATUS: Task['status'] = 'completed';\nconst DELETED_STATUS: Task['status'] = 'deleted';\n\n/** True when a non-empty list has no visible work left to finish. */\nexport function isTaskListComplete(taskList: readonly Task[]): boolean {\n  const visible = taskList.filter((task) => task.status !== DELETED_STATUS);\n  return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);\n}\n\n/**\n * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?\n *\n * Takes the proposed additions explicitly so the reducer can ask the question\n * before mutating anything.\n */\nexport function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {\n  const edges = new Map<number, number[]>();\n  for (const task of taskList) {\n    if (task.id === taskId) {\n      edges.set(task.id, [...new Set([...(task.blockedBy ?? []), ...newBlockedBy])]);\n    } else {\n      edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);\n    }\n  }\n\n  const visiting = new Set<number>();\n  const visited = new Set<number>();\n  const hasCycleFrom = (node: number): boolean => {\n    if (visiting.has(node)) return true;\n    if (visited.has(node)) return false;\n    visiting.add(node);\n    for (const next of edges.get(node) ?? []) {\n      if (hasCycleFrom(next)) return true;\n    }\n    visiting.delete(node);\n    visited.add(node);\n    return false;\n  };\n\n  for (const node of edges.keys()) {\n    if (hasCycleFrom(node)) return true;\n  }\n  return false;\n}\n\n/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */\nexport function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {\n  const blocks = new Map<number, number[]>();\n  for (const task of taskList) {\n    for (const dep of task.blockedBy ?? []) {\n      const dependents = blocks.get(dep) ?? [];\n      dependents.push(task.id);\n      blocks.set(dep, dependents);\n    }\n  }\n  return blocks;\n}\n\n/**\n * Blocking dependencies of a task that are not yet resolved.\n *\n * `completed` clears a dependency; `failed` deliberately does not, so a failed\n * delegation keeps its dependents blocked instead of silently releasing work\n * that was never actually finished.\n */\nexport function unresolvedBlockers(taskList: readonly Task[], task: Task): number[] {\n  return (task.blockedBy ?? []).filter((dep) => {\n    const blocker = taskList.find((candidate) => candidate.id === dep);\n    if (!blocker) return false;\n    return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;\n  });\n}\n\nexport function isBlocked(taskList: readonly Task[], task: Task): boolean {\n  return unresolvedBlockers(taskList, task).length > 0;\n}\n"],"mappings":";AAEA,MAAM,mBAAmC;AACzC,MAAM,iBAAiC;;AAGvC,SAAgB,mBAAmB,UAAoC;CACrE,MAAM,UAAU,SAAS,QAAQ,SAAS,KAAK,WAAW,cAAc;CACxE,OAAO,QAAQ,SAAS,KAAK,QAAQ,OAAO,SAAS,KAAK,WAAW,gBAAgB;AACvF;;;;;;;AAQA,SAAgB,YAAY,UAA2B,QAAgB,cAA0C;CAC/G,MAAM,wBAAQ,IAAI,IAAsB;CACxC,KAAK,MAAM,QAAQ,UACjB,IAAI,KAAK,OAAO,QACd,MAAM,IAAI,KAAK,IAAI,CAAC,mBAAG,IAAI,IAAI,CAAC,GAAI,KAAK,aAAa,CAAC,GAAI,GAAG,YAAY,CAAC,CAAC,CAAC;MAE7E,MAAM,IAAI,KAAK,IAAI,KAAK,YAAY,CAAC,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC;CAIhE,MAAM,2BAAW,IAAI,IAAY;CACjC,MAAM,0BAAU,IAAI,IAAY;CAChC,MAAM,gBAAgB,SAA0B;EAC9C,IAAI,SAAS,IAAI,IAAI,GAAG,OAAO;EAC/B,IAAI,QAAQ,IAAI,IAAI,GAAG,OAAO;EAC9B,SAAS,IAAI,IAAI;EACjB,KAAK,MAAM,QAAQ,MAAM,IAAI,IAAI,KAAK,CAAC,GACrC,IAAI,aAAa,IAAI,GAAG,OAAO;EAEjC,SAAS,OAAO,IAAI;EACpB,QAAQ,IAAI,IAAI;EAChB,OAAO;CACT;CAEA,KAAK,MAAM,QAAQ,MAAM,KAAK,GAC5B,IAAI,aAAa,IAAI,GAAG,OAAO;CAEjC,OAAO;AACT;;AAGA,SAAgB,aAAa,UAAkD;CAC7E,MAAM,yBAAS,IAAI,IAAsB;CACzC,KAAK,MAAM,QAAQ,UACjB,KAAK,MAAM,OAAO,KAAK,aAAa,CAAC,GAAG;EACtC,MAAM,aAAa,OAAO,IAAI,GAAG,KAAK,CAAC;EACvC,WAAW,KAAK,KAAK,EAAE;EACvB,OAAO,IAAI,KAAK,UAAU;CAC5B;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,mBAAmB,UAA2B,MAAsB;CAClF,QAAQ,KAAK,aAAa,CAAC,EAAA,CAAG,QAAQ,QAAQ;EAC5C,MAAM,UAAU,SAAS,MAAM,cAAc,UAAU,OAAO,GAAG;EACjE,IAAI,CAAC,SAAS,OAAO;EACrB,OAAO,QAAQ,WAAW,oBAAoB,QAAQ,WAAW;CACnE,CAAC;AACH;AAEA,SAAgB,UAAU,UAA2B,MAAqB;CACxE,OAAO,mBAAmB,UAAU,IAAI,CAAC,CAAC,SAAS;AACrD"}

package/dist/{store → src/models}/taskGraph.d.cts

@@ -1,16 +1,16 @@
-import { Task } from "./types.cjs";
-//#region src/store/taskGraph.d.ts
+import { Task } from "./task.cjs";
+//#region src/models/taskGraph.d.ts
 /** True when a non-empty list has no visible work left to finish. */
-declare function isTaskListComplete(taskList: readonly Task[]): boolean;
+export declare function isTaskListComplete(taskList: readonly Task[]): boolean;
 /**
  * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?
  *
  * Takes the proposed additions explicitly so the reducer can ask the question
  * before mutating anything.
  */
-declare function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean;
+export declare function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean;
 /** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
-declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
+export declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
 /**
  * Blocking dependencies of a task that are not yet resolved.
  *
@@ -18,8 +18,7 @@ declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
  * delegation keeps its dependents blocked instead of silently releasing work
  * that was never actually finished.
  */
-declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
-declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
+export declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
+export declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
 //#endregion
-export { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };
 //# sourceMappingURL=taskGraph.d.cts.map

package/dist/src/models/taskGraph.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph.d.cts","names":[],"sources":["../../../src/models/taskGraph.ts"],"mappings":";;;wBAMgB,mBAAmB,mBAAmB;;;;;;;wBAWtC,YAAY,mBAAmB,QAAQ,gBAAgB;;wBA+BvD,aAAa,mBAAmB,SAAS;;;;;;;;wBAmBzC,mBAAmB,mBAAmB,QAAQ,MAAM;wBAQpD,UAAU,mBAAmB,QAAQ,MAAM"}

package/dist/{store → src/models}/taskGraph.d.mts

@@ -1,16 +1,16 @@
-import { Task } from "./types.mjs";
-//#region src/store/taskGraph.d.ts
+import { Task } from "./task.mjs";
+//#region src/models/taskGraph.d.ts
 /** True when a non-empty list has no visible work left to finish. */
-declare function isTaskListComplete(taskList: readonly Task[]): boolean;
+export declare function isTaskListComplete(taskList: readonly Task[]): boolean;
 /**
  * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?
  *
  * Takes the proposed additions explicitly so the reducer can ask the question
  * before mutating anything.
  */
-declare function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean;
+export declare function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean;
 /** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
-declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
+export declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
 /**
  * Blocking dependencies of a task that are not yet resolved.
  *
@@ -18,8 +18,7 @@ declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
  * delegation keeps its dependents blocked instead of silently releasing work
  * that was never actually finished.
  */
-declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
-declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
+export declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
+export declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
 //#endregion
-export { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };
 //# sourceMappingURL=taskGraph.d.mts.map

package/dist/src/models/taskGraph.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph.d.mts","names":[],"sources":["../../../src/models/taskGraph.ts"],"mappings":";;;wBAMgB,mBAAmB,mBAAmB;;;;;;;wBAWtC,YAAY,mBAAmB,QAAQ,gBAAgB;;wBA+BvD,aAAa,mBAAmB,SAAS;;;;;;;;wBAmBzC,mBAAmB,mBAAmB,QAAQ,MAAM;wBAQpD,UAAU,mBAAmB,QAAQ,MAAM"}

package/dist/src/models/taskGraph.mjs

@@ -0,0 +1,63 @@
+//#region src/models/taskGraph.ts
+const COMPLETED_STATUS = "completed";
+const DELETED_STATUS = "deleted";
+/** True when a non-empty list has no visible work left to finish. */
+function isTaskListComplete(taskList) {
+	const visible = taskList.filter((task) => task.status !== DELETED_STATUS);
+	return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);
+}
+/**
+* Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?
+*
+* Takes the proposed additions explicitly so the reducer can ask the question
+* before mutating anything.
+*/
+function detectCycle(taskList, taskId, newBlockedBy) {
+	const edges = /* @__PURE__ */ new Map();
+	for (const task of taskList) if (task.id === taskId) edges.set(task.id, [.../* @__PURE__ */ new Set([...task.blockedBy ?? [], ...newBlockedBy])]);
+	else edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const hasCycleFrom = (node) => {
+		if (visiting.has(node)) return true;
+		if (visited.has(node)) return false;
+		visiting.add(node);
+		for (const next of edges.get(node) ?? []) if (hasCycleFrom(next)) return true;
+		visiting.delete(node);
+		visited.add(node);
+		return false;
+	};
+	for (const node of edges.keys()) if (hasCycleFrom(node)) return true;
+	return false;
+}
+/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
+function deriveBlocks(taskList) {
+	const blocks = /* @__PURE__ */ new Map();
+	for (const task of taskList) for (const dep of task.blockedBy ?? []) {
+		const dependents = blocks.get(dep) ?? [];
+		dependents.push(task.id);
+		blocks.set(dep, dependents);
+	}
+	return blocks;
+}
+/**
+* Blocking dependencies of a task that are not yet resolved.
+*
+* `completed` clears a dependency; `failed` deliberately does not, so a failed
+* delegation keeps its dependents blocked instead of silently releasing work
+* that was never actually finished.
+*/
+function unresolvedBlockers(taskList, task) {
+	return (task.blockedBy ?? []).filter((dep) => {
+		const blocker = taskList.find((candidate) => candidate.id === dep);
+		if (!blocker) return false;
+		return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;
+	});
+}
+function isBlocked(taskList, task) {
+	return unresolvedBlockers(taskList, task).length > 0;
+}
+//#endregion
+export { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };
+
+//# sourceMappingURL=taskGraph.mjs.map

package/dist/{store → src/models}/taskGraph.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"taskGraph.mjs","names":[],"sources":["../../src/store/taskGraph.ts"],"sourcesContent":["import type { Task } from './types.ts';\n\nconst COMPLETED_STATUS: Task['status'] = 'completed';\nconst DELETED_STATUS: Task['status'] = 'deleted';\n\n/** True when a non-empty list has no visible work left to finish. */\nexport function isTaskListComplete(taskList: readonly Task[]): boolean {\n  const visible = taskList.filter((task) => task.status !== DELETED_STATUS);\n  return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);\n}\n\n/**\n * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?\n *\n * Takes the proposed additions explicitly so the reducer can ask the question\n * before mutating anything.\n */\nexport function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {\n  const edges = new Map<number, number[]>();\n  for (const task of taskList) {\n    if (task.id === taskId) {\n      edges.set(task.id, [...new Set([...(task.blockedBy ?? []), ...newBlockedBy])]);\n    } else {\n      edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);\n    }\n  }\n\n  const visiting = new Set<number>();\n  const visited = new Set<number>();\n  const hasCycleFrom = (node: number): boolean => {\n    if (visiting.has(node)) return true;\n    if (visited.has(node)) return false;\n    visiting.add(node);\n    for (const next of edges.get(node) ?? []) {\n      if (hasCycleFrom(next)) return true;\n    }\n    visiting.delete(node);\n    visited.add(node);\n    return false;\n  };\n\n  for (const node of edges.keys()) {\n    if (hasCycleFrom(node)) return true;\n  }\n  return false;\n}\n\n/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */\nexport function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {\n  const blocks = new Map<number, number[]>();\n  for (const task of taskList) {\n    for (const dep of task.blockedBy ?? []) {\n      const dependents = blocks.get(dep) ?? [];\n      dependents.push(task.id);\n      blocks.set(dep, dependents);\n    }\n  }\n  return blocks;\n}\n\n/**\n * Blocking dependencies of a task that are not yet resolved.\n *\n * `completed` clears a dependency; `failed` deliberately does not, so a failed\n * delegation keeps its dependents blocked instead of silently releasing work\n * that was never actually finished.\n */\nexport function unresolvedBlockers(taskList: readonly Task[], task: Task): number[] {\n  return (task.blockedBy ?? []).filter((dep) => {\n    const blocker = taskList.find((candidate) => candidate.id === dep);\n    if (!blocker) return false;\n    return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;\n  });\n}\n\nexport function isBlocked(taskList: readonly Task[], task: Task): boolean {\n  return unresolvedBlockers(taskList, task).length > 0;\n}\n"],"mappings":"AAEA,MAAM,EAAmC,YACnC,EAAiC,UAGvC,SAAgB,EAAmB,EAAoC,CACrE,IAAM,EAAU,EAAS,OAAQ,GAAS,EAAK,SAAW,CAAc,EACxE,OAAO,EAAQ,OAAS,GAAK,EAAQ,MAAO,GAAS,EAAK,SAAW,CAAgB,CACvF,CAQA,SAAgB,EAAY,EAA2B,EAAgB,EAA0C,CAC/G,IAAM,EAAQ,IAAI,IAClB,IAAK,IAAM,KAAQ,EACb,EAAK,KAAO,EACd,EAAM,IAAI,EAAK,GAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAI,EAAK,WAAa,CAAC,EAAI,GAAG,CAAY,CAAC,CAAC,CAAC,EAE7E,EAAM,IAAI,EAAK,GAAI,EAAK,UAAY,CAAC,GAAG,EAAK,SAAS,EAAI,CAAC,CAAC,EAIhE,IAAM,EAAW,IAAI,IACf,EAAU,IAAI,IACd,EAAgB,GAA0B,CAC9C,GAAI,EAAS,IAAI,CAAI,EAAG,MAAO,GAC/B,GAAI,EAAQ,IAAI,CAAI,EAAG,MAAO,GAC9B,EAAS,IAAI,CAAI,EACjB,IAAK,IAAM,KAAQ,EAAM,IAAI,CAAI,GAAK,CAAC,EACrC,GAAI,EAAa,CAAI,EAAG,MAAO,GAIjC,OAFA,EAAS,OAAO,CAAI,EACpB,EAAQ,IAAI,CAAI,EACT,EACT,EAEA,IAAK,IAAM,KAAQ,EAAM,KAAK,EAC5B,GAAI,EAAa,CAAI,EAAG,MAAO,GAEjC,MAAO,EACT,CAGA,SAAgB,EAAa,EAAkD,CAC7E,IAAM,EAAS,IAAI,IACnB,IAAK,IAAM,KAAQ,EACjB,IAAK,IAAM,KAAO,EAAK,WAAa,CAAC,EAAG,CACtC,IAAM,EAAa,EAAO,IAAI,CAAG,GAAK,CAAC,EACvC,EAAW,KAAK,EAAK,EAAE,EACvB,EAAO,IAAI,EAAK,CAAU,CAC5B,CAEF,OAAO,CACT,CASA,SAAgB,EAAmB,EAA2B,EAAsB,CAClF,OAAQ,EAAK,WAAa,CAAC,EAAA,CAAG,OAAQ,GAAQ,CAC5C,IAAM,EAAU,EAAS,KAAM,GAAc,EAAU,KAAO,CAAG,EAEjE,OADK,EACE,EAAQ,SAAW,GAAoB,EAAQ,SAAW,EAD5C,EAEvB,CAAC,CACH,CAEA,SAAgB,EAAU,EAA2B,EAAqB,CACxE,OAAO,EAAmB,EAAU,CAAI,CAAC,CAAC,OAAS,CACrD"}
+{"version":3,"file":"taskGraph.mjs","names":[],"sources":["../../../src/models/taskGraph.ts"],"sourcesContent":["import type { Task } from './task';\n\nconst COMPLETED_STATUS: Task['status'] = 'completed';\nconst DELETED_STATUS: Task['status'] = 'deleted';\n\n/** True when a non-empty list has no visible work left to finish. */\nexport function isTaskListComplete(taskList: readonly Task[]): boolean {\n  const visible = taskList.filter((task) => task.status !== DELETED_STATUS);\n  return visible.length > 0 && visible.every((task) => task.status === COMPLETED_STATUS);\n}\n\n/**\n * Would merging `newBlockedBy` into `taskId`'s dependencies introduce a cycle?\n *\n * Takes the proposed additions explicitly so the reducer can ask the question\n * before mutating anything.\n */\nexport function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {\n  const edges = new Map<number, number[]>();\n  for (const task of taskList) {\n    if (task.id === taskId) {\n      edges.set(task.id, [...new Set([...(task.blockedBy ?? []), ...newBlockedBy])]);\n    } else {\n      edges.set(task.id, task.blockedBy ? [...task.blockedBy] : []);\n    }\n  }\n\n  const visiting = new Set<number>();\n  const visited = new Set<number>();\n  const hasCycleFrom = (node: number): boolean => {\n    if (visiting.has(node)) return true;\n    if (visited.has(node)) return false;\n    visiting.add(node);\n    for (const next of edges.get(node) ?? []) {\n      if (hasCycleFrom(next)) return true;\n    }\n    visiting.delete(node);\n    visited.add(node);\n    return false;\n  };\n\n  for (const node of edges.keys()) {\n    if (hasCycleFrom(node)) return true;\n  }\n  return false;\n}\n\n/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */\nexport function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {\n  const blocks = new Map<number, number[]>();\n  for (const task of taskList) {\n    for (const dep of task.blockedBy ?? []) {\n      const dependents = blocks.get(dep) ?? [];\n      dependents.push(task.id);\n      blocks.set(dep, dependents);\n    }\n  }\n  return blocks;\n}\n\n/**\n * Blocking dependencies of a task that are not yet resolved.\n *\n * `completed` clears a dependency; `failed` deliberately does not, so a failed\n * delegation keeps its dependents blocked instead of silently releasing work\n * that was never actually finished.\n */\nexport function unresolvedBlockers(taskList: readonly Task[], task: Task): number[] {\n  return (task.blockedBy ?? []).filter((dep) => {\n    const blocker = taskList.find((candidate) => candidate.id === dep);\n    if (!blocker) return false;\n    return blocker.status !== COMPLETED_STATUS && blocker.status !== DELETED_STATUS;\n  });\n}\n\nexport function isBlocked(taskList: readonly Task[], task: Task): boolean {\n  return unresolvedBlockers(taskList, task).length > 0;\n}\n"],"mappings":";AAEA,MAAM,mBAAmC;AACzC,MAAM,iBAAiC;;AAGvC,SAAgB,mBAAmB,UAAoC;CACrE,MAAM,UAAU,SAAS,QAAQ,SAAS,KAAK,WAAW,cAAc;CACxE,OAAO,QAAQ,SAAS,KAAK,QAAQ,OAAO,SAAS,KAAK,WAAW,gBAAgB;AACvF;;;;;;;AAQA,SAAgB,YAAY,UAA2B,QAAgB,cAA0C;CAC/G,MAAM,wBAAQ,IAAI,IAAsB;CACxC,KAAK,MAAM,QAAQ,UACjB,IAAI,KAAK,OAAO,QACd,MAAM,IAAI,KAAK,IAAI,CAAC,mBAAG,IAAI,IAAI,CAAC,GAAI,KAAK,aAAa,CAAC,GAAI,GAAG,YAAY,CAAC,CAAC,CAAC;MAE7E,MAAM,IAAI,KAAK,IAAI,KAAK,YAAY,CAAC,GAAG,KAAK,SAAS,IAAI,CAAC,CAAC;CAIhE,MAAM,2BAAW,IAAI,IAAY;CACjC,MAAM,0BAAU,IAAI,IAAY;CAChC,MAAM,gBAAgB,SAA0B;EAC9C,IAAI,SAAS,IAAI,IAAI,GAAG,OAAO;EAC/B,IAAI,QAAQ,IAAI,IAAI,GAAG,OAAO;EAC9B,SAAS,IAAI,IAAI;EACjB,KAAK,MAAM,QAAQ,MAAM,IAAI,IAAI,KAAK,CAAC,GACrC,IAAI,aAAa,IAAI,GAAG,OAAO;EAEjC,SAAS,OAAO,IAAI;EACpB,QAAQ,IAAI,IAAI;EAChB,OAAO;CACT;CAEA,KAAK,MAAM,QAAQ,MAAM,KAAK,GAC5B,IAAI,aAAa,IAAI,GAAG,OAAO;CAEjC,OAAO;AACT;;AAGA,SAAgB,aAAa,UAAkD;CAC7E,MAAM,yBAAS,IAAI,IAAsB;CACzC,KAAK,MAAM,QAAQ,UACjB,KAAK,MAAM,OAAO,KAAK,aAAa,CAAC,GAAG;EACtC,MAAM,aAAa,OAAO,IAAI,GAAG,KAAK,CAAC;EACvC,WAAW,KAAK,KAAK,EAAE;EACvB,OAAO,IAAI,KAAK,UAAU;CAC5B;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,mBAAmB,UAA2B,MAAsB;CAClF,QAAQ,KAAK,aAAa,CAAC,EAAA,CAAG,QAAQ,QAAQ;EAC5C,MAAM,UAAU,SAAS,MAAM,cAAc,UAAU,OAAO,GAAG;EACjE,IAAI,CAAC,SAAS,OAAO;EACrB,OAAO,QAAQ,WAAW,oBAAoB,QAAQ,WAAW;CACnE,CAAC;AACH;AAEA,SAAgB,UAAU,UAA2B,MAAqB;CACxE,OAAO,mBAAmB,UAAU,IAAI,CAAC,CAAC,SAAS;AACrD"}