@agimon-ai/doompi-task 0.0.1-alpha.75 → 0.0.1-alpha.76

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

@@ -0,0 +1,186 @@
+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. */
+export interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+/**
+ * Delegation bookkeeping attached to a task that was handed to a subagent.
+ *
+ * `pid` is the harness process that owns the run: it is the only way to tell an
+ * genuinely-running delegation from one orphaned by a harness crash, since the
+ * child dies with its parent but the file survives.
+ */
+export interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+export interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+export declare const STORE_SCHEMA_VERSION = 1;
+/** The complete on-disk document. `rev` increments on every committed write. */
+export interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+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.
+ *
+ * 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`.
+ */
+export type DepToken = number | string;
+/**
+ * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
+ *
+ * `blockedBy` (absolute set) is create-only and `addBlockedBy`/`removeBlockedBy`
+ * (additive merge) are update-only, matching the split the two former actions
+ * had. A field used against the wrong kind fails that item rather than being
+ * silently ignored.
+ */
+export interface TaskItemMutation {
+  id?: number;
+  ref?: string;
+  subject?: string;
+  description?: string;
+  activeForm?: string;
+  status?: TaskStatus;
+  blockedBy?: DepToken[];
+  addBlockedBy?: DepToken[];
+  removeBlockedBy?: DepToken[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * What one upsert item did. `index` is its position in the request array, so a
+ * model reading a partial result can tell which entries still need resending.
+ *
+ * `message` is unprefixed: the `item[N] failed:` framing belongs to the
+ * formatter, because the Task Space overlay shows this text on its own.
+ */
+export type UpsertItemOutcome = {
+  index: number;
+  kind: 'created';
+  id: number;
+  subject: string;
+  status: TaskStatus;
+  ref?: string;
+  blockedBy?: number[];
+} | {
+  index: number;
+  kind: 'updated';
+  id: number;
+  fromStatus: TaskStatus;
+  toStatus: TaskStatus;
+} | {
+  index: number;
+  kind: 'unchanged';
+  id: number;
+  status: TaskStatus;
+} | {
+  index: number;
+  kind: 'failed';
+  message: string;
+  id?: number;
+  ref?: string;
+};
+/** Which tasks an upsert touched, so renderResult names them instead of guessing. */
+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
+ * casting each field.
+ *
+ * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
+ * `status` would be ambiguous once one call can carry many tasks.
+ */
+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`, and `cancel` only. Assign ids live in `assignments[]`. */
+  id?: number;
+  includeDeleted?: boolean;
+}
+/** Snapshot returned under a tool result's `details` for renderResult. */
+export interface TaskDetails {
+  action: TaskAction;
+  params: Record<string, unknown>;
+  tasks: Task[];
+  nextId: number;
+  rev: number;
+  error?: string;
+  upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
+}
+/**
+ * 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
+//# 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/src/models/task.d.mts

@@ -0,0 +1,186 @@
+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. */
+export interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+/**
+ * Delegation bookkeeping attached to a task that was handed to a subagent.
+ *
+ * `pid` is the harness process that owns the run: it is the only way to tell an
+ * genuinely-running delegation from one orphaned by a harness crash, since the
+ * child dies with its parent but the file survives.
+ */
+export interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+export interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+export declare const STORE_SCHEMA_VERSION = 1;
+/** The complete on-disk document. `rev` increments on every committed write. */
+export interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+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.
+ *
+ * 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`.
+ */
+export type DepToken = number | string;
+/**
+ * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
+ *
+ * `blockedBy` (absolute set) is create-only and `addBlockedBy`/`removeBlockedBy`
+ * (additive merge) are update-only, matching the split the two former actions
+ * had. A field used against the wrong kind fails that item rather than being
+ * silently ignored.
+ */
+export interface TaskItemMutation {
+  id?: number;
+  ref?: string;
+  subject?: string;
+  description?: string;
+  activeForm?: string;
+  status?: TaskStatus;
+  blockedBy?: DepToken[];
+  addBlockedBy?: DepToken[];
+  removeBlockedBy?: DepToken[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * What one upsert item did. `index` is its position in the request array, so a
+ * model reading a partial result can tell which entries still need resending.
+ *
+ * `message` is unprefixed: the `item[N] failed:` framing belongs to the
+ * formatter, because the Task Space overlay shows this text on its own.
+ */
+export type UpsertItemOutcome = {
+  index: number;
+  kind: 'created';
+  id: number;
+  subject: string;
+  status: TaskStatus;
+  ref?: string;
+  blockedBy?: number[];
+} | {
+  index: number;
+  kind: 'updated';
+  id: number;
+  fromStatus: TaskStatus;
+  toStatus: TaskStatus;
+} | {
+  index: number;
+  kind: 'unchanged';
+  id: number;
+  status: TaskStatus;
+} | {
+  index: number;
+  kind: 'failed';
+  message: string;
+  id?: number;
+  ref?: string;
+};
+/** Which tasks an upsert touched, so renderResult names them instead of guessing. */
+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
+ * casting each field.
+ *
+ * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
+ * `status` would be ambiguous once one call can carry many tasks.
+ */
+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`, and `cancel` only. Assign ids live in `assignments[]`. */
+  id?: number;
+  includeDeleted?: boolean;
+}
+/** Snapshot returned under a tool result's `details` for renderResult. */
+export interface TaskDetails {
+  action: TaskAction;
+  params: Record<string, unknown>;
+  tasks: Task[];
+  nextId: number;
+  rev: number;
+  error?: string;
+  upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
+}
+/**
+ * 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
+//# 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/src/models/taskGraph.cjs.map

@@ -0,0 +1 @@
+{"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/src/models/taskGraph.d.cts

@@ -0,0 +1,24 @@
+import { Task } from "./task.cjs";
+//#region src/models/taskGraph.d.ts
+/** True when a non-empty list has no visible work left to finish. */
+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.
+ */
+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. */
+export declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
+/**
+ * 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.
+ */
+export declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
+export declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
+//#endregion
+//# 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/src/models/taskGraph.d.mts

@@ -0,0 +1,24 @@
+import { Task } from "./task.mjs";
+//#region src/models/taskGraph.d.ts
+/** True when a non-empty list has no visible work left to finish. */
+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.
+ */
+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. */
+export declare function deriveBlocks(taskList: readonly Task[]): Map<number, number[]>;
+/**
+ * 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.
+ */
+export declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
+export declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
+//#endregion
+//# 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/src/models/taskGraph.mjs.map

@@ -0,0 +1 @@
+{"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"}