@agimon-ai/po-task 0.0.0-alpha.0

package/dist/task-UvW877Ez.cjs

@@ -0,0 +1,227 @@
+require("./delegation-LDpHP2CC.cjs");
+let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
+let typebox = require("typebox");
+//#region src/constants/task.ts
+const COMMAND_NAME = "tasks";
+//#endregion
+//#region src/schemas/task.ts
+const TASK_ACTIONS = [
+	"upsert",
+	"list",
+	"get",
+	"delete",
+	"clear",
+	"assign",
+	"cancel"
+];
+const TASK_STATUSES = [
+	"pending",
+	"in_progress",
+	"completed",
+	"failed",
+	"deleted"
+];
+const TASK_CONTEXTS = ["fresh", "fork"];
+const TOOL_NAME = "task";
+const TOOL_LABEL = "Task";
+const ERR_REQUIRES_INTERACTIVE = "/tasks requires interactive mode";
+const MSG_NO_TASKS = "No tasks yet. Ask the agent to add some!";
+/**
+* Which top-level fields each action accepts.
+*
+* The params object is flat and shared across every action, so the schema alone
+* cannot express "upsert has no top-level id". That gap matters: a call like
+* `{"action":"upsert","id":3,"tasks":[{"status":"completed"}]}` would otherwise
+* silently create a duplicate task, because the entry itself carries no id.
+*/
+const TASK_ACTION_FIELDS = {
+	upsert: ["action", "tasks"],
+	list: [
+		"action",
+		"status",
+		"includeDeleted"
+	],
+	get: ["action", "id"],
+	delete: ["action", "id"],
+	clear: ["action"],
+	assign: ["action", "assignments"],
+	cancel: ["action", "id"]
+};
+function taskActionAcceptsField(action, field) {
+	return TASK_ACTION_FIELDS[action].includes(field);
+}
+/** Correction hint appended when a per-task field lands at the top level. */
+const MSG_UPSERT_FIELD_MISPLACED = "Per-task fields belong inside each tasks[] entry, not at the top level: {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}.";
+/**
+* A dependency target: an existing task id, or the `ref` of a task created
+* earlier in the same call.
+*/
+const DepTokenSchema = typebox.Type.Union([typebox.Type.Integer(), typebox.Type.String()]);
+/**
+* One entry of an upsert. `additionalProperties: false` is load-bearing: pi
+* validates tool arguments against this schema before `execute` runs, so a
+* stray `{"action":"update"}` inside an entry is rejected at the boundary.
+*/
+const TaskItemSchema = typebox.Type.Object({
+	id: typebox.Type.Optional(typebox.Type.Integer({ description: "Existing task id to change. Omit to create. An unknown id fails only that entry; it never creates." })),
+	ref: typebox.Type.Optional(typebox.Type.String({ description: "Temporary name for a task created by this entry, so a LATER entry in this array can list it in blockedBy. Must start with a letter; never stored." })),
+	subject: typebox.Type.Optional(typebox.Type.String({ description: "Short imperative subject. Required when the entry has no id; on an entry with an id it renames." })),
+	description: typebox.Type.Optional(typebox.Type.String({ description: "Long-form detail; becomes the brief handed to the subagent on assign." })),
+	activeForm: typebox.Type.Optional(typebox.Type.String({ description: "Present-continuous label shown while in_progress (e.g. 'writing tests')" })),
+	status: typebox.Type.Optional(typebox.Type.String({
+		enum: [...TASK_STATUSES],
+		description: "New entries default to pending and cannot start deleted; on an entry with an id the transition must be legal."
+	})),
+	blockedBy: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies for a NEW entry: task ids, or refs of tasks created EARLIER in this array. On an entry with an id use addBlockedBy / removeBlockedBy instead." })),
+	addBlockedBy: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to add (ids or earlier refs). Additive; do not resend the full array." })),
+	removeBlockedBy: typebox.Type.Optional(typebox.Type.Array(DepTokenSchema, { description: "Dependencies to remove. Additive; do not resend the full array." })),
+	owner: typebox.Type.Optional(typebox.Type.String({ description: "Owner label; assign sets it to the subagent name." })),
+	metadata: typebox.Type.Optional(typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown(), { description: "Merged into the task; a null value deletes that key." }))
+}, { additionalProperties: false });
+/** One task-to-agent handoff in a native assignment batch. */
+const TaskAssignmentSchema = typebox.Type.Object({
+	id: typebox.Type.Integer({ description: "Pending, unblocked task id to delegate" }),
+	agent: typebox.Type.String({ description: "Exact discovered subagent name" }),
+	inlineAgent: typebox.Type.Optional(_agimon_ai_po_core_delegation.InlineAgentSchema),
+	instructions: typebox.Type.Optional(typebox.Type.String({ description: "Extra instructions appended to this delegated brief" })),
+	relevantFiles: typebox.Type.Optional(typebox.Type.Array(typebox.Type.String(), { description: `Files already read or located, relative to the working directory; at most 12 are used.` })),
+	priorFindings: typebox.Type.Optional(typebox.Type.String({ description: "Established facts this child should consume rather than re-derive" })),
+	model: typebox.Type.Optional(typebox.Type.String({ description: "Model override for this delegated run" })),
+	context: typebox.Type.Optional(typebox.Type.String({
+		enum: [...TASK_CONTEXTS],
+		description: "Starting context for this child: 'fresh' or 'fork'"
+	}))
+}, { additionalProperties: false });
+/**
+* Tool parameters. Every `description` doubles as LLM-facing prompt copy, so
+* wording changes here change model behaviour.
+*/
+const TaskParamsSchema = typebox.Type.Object({
+	action: typebox.Type.String({ enum: [...TASK_ACTIONS] }),
+	tasks: typebox.Type.Optional(typebox.Type.Array(TaskItemSchema, {
+		minItems: 1,
+		description: "upsert only. An entry with an id changes that task, an entry without an id creates one. Entries apply in array order, so a later entry can depend on an earlier one by ref."
+	})),
+	assignments: typebox.Type.Optional(typebox.Type.Array(TaskAssignmentSchema, {
+		minItems: 1,
+		description: "Required for assign, one entry per task, including when there is only one."
+	})),
+	id: typebox.Type.Optional(typebox.Type.Integer({ description: "Task id, for get, delete and cancel. Not accepted by upsert or assign: those carry ids inside tasks[] and assignments[] entries." })),
+	status: typebox.Type.Optional(typebox.Type.String({
+		enum: [...TASK_STATUSES],
+		description: "list only: return just the tasks in this status. To SET a status, upsert the task by id."
+	})),
+	includeDeleted: typebox.Type.Optional(typebox.Type.Boolean({ description: "list only: also return deleted tombstones. Default false." }))
+});
+/** Remote MCP connections track tasks only; delegation stays with the local agent. */
+const REMOTE_TASK_ACTIONS = [
+	"upsert",
+	"list",
+	"get",
+	"delete",
+	"clear"
+];
+const { assignments: _assignments, ...remoteTaskProperties } = TaskParamsSchema.properties;
+const RemoteTaskParamsSchema = typebox.Type.Object({
+	...remoteTaskProperties,
+	action: typebox.Type.String({ enum: [...REMOTE_TASK_ACTIONS] })
+});
+//#endregion
+Object.defineProperty(exports, "COMMAND_NAME", {
+	enumerable: true,
+	get: function() {
+		return COMMAND_NAME;
+	}
+});
+Object.defineProperty(exports, "ERR_REQUIRES_INTERACTIVE", {
+	enumerable: true,
+	get: function() {
+		return ERR_REQUIRES_INTERACTIVE;
+	}
+});
+Object.defineProperty(exports, "MSG_NO_TASKS", {
+	enumerable: true,
+	get: function() {
+		return MSG_NO_TASKS;
+	}
+});
+Object.defineProperty(exports, "MSG_UPSERT_FIELD_MISPLACED", {
+	enumerable: true,
+	get: function() {
+		return MSG_UPSERT_FIELD_MISPLACED;
+	}
+});
+Object.defineProperty(exports, "REMOTE_TASK_ACTIONS", {
+	enumerable: true,
+	get: function() {
+		return REMOTE_TASK_ACTIONS;
+	}
+});
+Object.defineProperty(exports, "RemoteTaskParamsSchema", {
+	enumerable: true,
+	get: function() {
+		return RemoteTaskParamsSchema;
+	}
+});
+Object.defineProperty(exports, "TASK_ACTIONS", {
+	enumerable: true,
+	get: function() {
+		return TASK_ACTIONS;
+	}
+});
+Object.defineProperty(exports, "TASK_ACTION_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return TASK_ACTION_FIELDS;
+	}
+});
+Object.defineProperty(exports, "TASK_CONTEXTS", {
+	enumerable: true,
+	get: function() {
+		return TASK_CONTEXTS;
+	}
+});
+Object.defineProperty(exports, "TASK_STATUSES", {
+	enumerable: true,
+	get: function() {
+		return TASK_STATUSES;
+	}
+});
+Object.defineProperty(exports, "TOOL_LABEL", {
+	enumerable: true,
+	get: function() {
+		return TOOL_LABEL;
+	}
+});
+Object.defineProperty(exports, "TOOL_NAME", {
+	enumerable: true,
+	get: function() {
+		return TOOL_NAME;
+	}
+});
+Object.defineProperty(exports, "TaskAssignmentSchema", {
+	enumerable: true,
+	get: function() {
+		return TaskAssignmentSchema;
+	}
+});
+Object.defineProperty(exports, "TaskItemSchema", {
+	enumerable: true,
+	get: function() {
+		return TaskItemSchema;
+	}
+});
+Object.defineProperty(exports, "TaskParamsSchema", {
+	enumerable: true,
+	get: function() {
+		return TaskParamsSchema;
+	}
+});
+Object.defineProperty(exports, "taskActionAcceptsField", {
+	enumerable: true,
+	get: function() {
+		return taskActionAcceptsField;
+	}
+});
+
+//# sourceMappingURL=task-UvW877Ez.cjs.map

package/dist/task-UvW877Ez.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-UvW877Ez.cjs","names":["Type","InlineAgentSchema"],"sources":["../src/constants/task.ts","../src/schemas/task.ts"],"sourcesContent":["export const COMMAND_NAME = 'tasks';\n","export { COMMAND_NAME } from '../constants/task';\nimport { InlineAgentSchema } from '@agimon-ai/po-core/delegation';\nimport { type Static, Type } from 'typebox';\n\nimport type { TaskAction } from '../models/task';\nimport { MAX_BRIEF_FILES } from '../types/delegation';\n\nexport const TASK_ACTIONS = ['upsert', 'list', 'get', 'delete', 'clear', 'assign', 'cancel'] as const;\nexport const TASK_STATUSES = ['pending', 'in_progress', 'completed', 'failed', 'deleted'] as const;\nexport const TASK_CONTEXTS = ['fresh', 'fork'] as const;\n\nexport const TOOL_NAME = 'task';\nexport const TOOL_LABEL = 'Task';\n\nexport const ERR_REQUIRES_INTERACTIVE = '/tasks requires interactive mode';\nexport const MSG_NO_TASKS = 'No tasks yet. Ask the agent to add some!';\n\n/**\n * Which top-level fields each action accepts.\n *\n * The params object is flat and shared across every action, so the schema alone\n * cannot express \"upsert has no top-level id\". That gap matters: a call like\n * `{\"action\":\"upsert\",\"id\":3,\"tasks\":[{\"status\":\"completed\"}]}` would otherwise\n * silently create a duplicate task, because the entry itself carries no id.\n */\nexport const TASK_ACTION_FIELDS = {\n  upsert: ['action', 'tasks'],\n  list: ['action', 'status', 'includeDeleted'],\n  get: ['action', 'id'],\n  delete: ['action', 'id'],\n  clear: ['action'],\n  assign: ['action', 'assignments'],\n  cancel: ['action', 'id'],\n} as const satisfies Record<TaskAction, readonly string[]>;\n\nexport function taskActionAcceptsField(action: TaskAction, field: string): boolean {\n  return (TASK_ACTION_FIELDS[action] as readonly string[]).includes(field);\n}\n\n/** Correction hint appended when a per-task field lands at the top level. */\nexport const MSG_UPSERT_FIELD_MISPLACED =\n  'Per-task fields belong inside each tasks[] entry, not at the top level: {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}.';\n\n/**\n * A dependency target: an existing task id, or the `ref` of a task created\n * earlier in the same call.\n */\nconst DepTokenSchema = Type.Union([Type.Integer(), Type.String()]);\n\n/**\n * One entry of an upsert. `additionalProperties: false` is load-bearing: pi\n * validates tool arguments against this schema before `execute` runs, so a\n * stray `{\"action\":\"update\"}` inside an entry is rejected at the boundary.\n */\nexport const TaskItemSchema = Type.Object(\n  {\n    id: Type.Optional(\n      Type.Integer({\n        description:\n          'Existing task id to change. Omit to create. An unknown id fails only that entry; it never creates.',\n      }),\n    ),\n    ref: Type.Optional(\n      Type.String({\n        description:\n          'Temporary name for a task created by this entry, so a LATER entry in this array can list it in blockedBy. Must start with a letter; never stored.',\n      }),\n    ),\n    subject: Type.Optional(\n      Type.String({\n        description: 'Short imperative subject. Required when the entry has no id; on an entry with an id it renames.',\n      }),\n    ),\n    description: Type.Optional(\n      Type.String({ description: 'Long-form detail; becomes the brief handed to the subagent on assign.' }),\n    ),\n    activeForm: Type.Optional(\n      Type.String({ description: \"Present-continuous label shown while in_progress (e.g. 'writing tests')\" }),\n    ),\n    status: Type.Optional(\n      Type.String({\n        enum: [...TASK_STATUSES],\n        description:\n          'New entries default to pending and cannot start deleted; on an entry with an id the transition must be legal.',\n      }),\n    ),\n    blockedBy: Type.Optional(\n      Type.Array(DepTokenSchema, {\n        description:\n          'Dependencies for a NEW entry: task ids, or refs of tasks created EARLIER in this array. On an entry with an id use addBlockedBy / removeBlockedBy instead.',\n      }),\n    ),\n    addBlockedBy: Type.Optional(\n      Type.Array(DepTokenSchema, {\n        description: 'Dependencies to add (ids or earlier refs). Additive; do not resend the full array.',\n      }),\n    ),\n    removeBlockedBy: Type.Optional(\n      Type.Array(DepTokenSchema, {\n        description: 'Dependencies to remove. Additive; do not resend the full array.',\n      }),\n    ),\n    owner: Type.Optional(Type.String({ description: 'Owner label; assign sets it to the subagent name.' })),\n    metadata: Type.Optional(\n      Type.Record(Type.String(), Type.Unknown(), {\n        description: 'Merged into the task; a null value deletes that key.',\n      }),\n    ),\n  },\n  { additionalProperties: false },\n);\n\n/** One task-to-agent handoff in a native assignment batch. */\nexport const TaskAssignmentSchema = Type.Object(\n  {\n    id: Type.Integer({ description: 'Pending, unblocked task id to delegate' }),\n    agent: Type.String({ description: 'Exact discovered subagent name' }),\n    inlineAgent: Type.Optional(InlineAgentSchema),\n    instructions: Type.Optional(Type.String({ description: 'Extra instructions appended to this delegated brief' })),\n    relevantFiles: Type.Optional(\n      Type.Array(Type.String(), {\n        description: `Files already read or located, relative to the working directory; at most ${MAX_BRIEF_FILES} are used.`,\n      }),\n    ),\n    priorFindings: Type.Optional(\n      Type.String({ description: 'Established facts this child should consume rather than re-derive' }),\n    ),\n    model: Type.Optional(Type.String({ description: 'Model override for this delegated run' })),\n    context: Type.Optional(\n      Type.String({\n        enum: [...TASK_CONTEXTS],\n        description: \"Starting context for this child: 'fresh' or 'fork'\",\n      }),\n    ),\n  },\n  { additionalProperties: false },\n);\n\n/**\n * Tool parameters. Every `description` doubles as LLM-facing prompt copy, so\n * wording changes here change model behaviour.\n */\nexport const TaskParamsSchema = Type.Object({\n  action: Type.String({ enum: [...TASK_ACTIONS] }),\n  tasks: Type.Optional(\n    Type.Array(TaskItemSchema, {\n      minItems: 1,\n      description:\n        'upsert only. An entry with an id changes that task, an entry without an id creates one. Entries apply in array order, so a later entry can depend on an earlier one by ref.',\n    }),\n  ),\n  assignments: Type.Optional(\n    Type.Array(TaskAssignmentSchema, {\n      minItems: 1,\n      description: 'Required for assign, one entry per task, including when there is only one.',\n    }),\n  ),\n  id: Type.Optional(\n    Type.Integer({\n      description:\n        'Task id, for get, delete and cancel. Not accepted by upsert or assign: those carry ids inside tasks[] and assignments[] entries.',\n    }),\n  ),\n  status: Type.Optional(\n    Type.String({\n      enum: [...TASK_STATUSES],\n      description: 'list only: return just the tasks in this status. To SET a status, upsert the task by id.',\n    }),\n  ),\n  includeDeleted: Type.Optional(\n    Type.Boolean({ description: 'list only: also return deleted tombstones. Default false.' }),\n  ),\n});\n\n/** Remote MCP connections track tasks only; delegation stays with the local agent. */\nexport const REMOTE_TASK_ACTIONS = ['upsert', 'list', 'get', 'delete', 'clear'] as const;\nconst { assignments: _assignments, ...remoteTaskProperties } = TaskParamsSchema.properties;\nexport const RemoteTaskParamsSchema = Type.Object({\n  ...remoteTaskProperties,\n  action: Type.String({ enum: [...REMOTE_TASK_ACTIONS] }),\n});\n\nexport type TaskItemParams = Static<typeof TaskItemSchema>;\nexport type TaskAssignmentParams = Static<typeof TaskAssignmentSchema>;\nexport type TaskParams = Static<typeof TaskParamsSchema>;\n"],"mappings":";;;;AAAA,MAAa,eAAe;;;ACO5B,MAAa,eAAe;CAAC;CAAU;CAAQ;CAAO;CAAU;CAAS;CAAU;AAAQ;AAC3F,MAAa,gBAAgB;CAAC;CAAW;CAAe;CAAa;CAAU;AAAS;AACxF,MAAa,gBAAgB,CAAC,SAAS,MAAM;AAE7C,MAAa,YAAY;AACzB,MAAa,aAAa;AAE1B,MAAa,2BAA2B;AACxC,MAAa,eAAe;;;;;;;;;AAU5B,MAAa,qBAAqB;CAChC,QAAQ,CAAC,UAAU,OAAO;CAC1B,MAAM;EAAC;EAAU;EAAU;CAAgB;CAC3C,KAAK,CAAC,UAAU,IAAI;CACpB,QAAQ,CAAC,UAAU,IAAI;CACvB,OAAO,CAAC,QAAQ;CAChB,QAAQ,CAAC,UAAU,aAAa;CAChC,QAAQ,CAAC,UAAU,IAAI;AACzB;AAEA,SAAgB,uBAAuB,QAAoB,OAAwB;CACjF,OAAQ,mBAAmB,OAAO,CAAuB,SAAS,KAAK;AACzE;;AAGA,MAAa,6BACX;;;;;AAMF,MAAM,iBAAiBA,QAAAA,KAAK,MAAM,CAACA,QAAAA,KAAK,QAAQ,GAAGA,QAAAA,KAAK,OAAO,CAAC,CAAC;;;;;;AAOjE,MAAa,iBAAiBA,QAAAA,KAAK,OACjC;CACE,IAAIA,QAAAA,KAAK,SACPA,QAAAA,KAAK,QAAQ,EACX,aACE,qGACJ,CAAC,CACH;CACA,KAAKA,QAAAA,KAAK,SACRA,QAAAA,KAAK,OAAO,EACV,aACE,oJACJ,CAAC,CACH;CACA,SAASA,QAAAA,KAAK,SACZA,QAAAA,KAAK,OAAO,EACV,aAAa,kGACf,CAAC,CACH;CACA,aAAaA,QAAAA,KAAK,SAChBA,QAAAA,KAAK,OAAO,EAAE,aAAa,wEAAwE,CAAC,CACtG;CACA,YAAYA,QAAAA,KAAK,SACfA,QAAAA,KAAK,OAAO,EAAE,aAAa,0EAA0E,CAAC,CACxG;CACA,QAAQA,QAAAA,KAAK,SACXA,QAAAA,KAAK,OAAO;EACV,MAAM,CAAC,GAAG,aAAa;EACvB,aACE;CACJ,CAAC,CACH;CACA,WAAWA,QAAAA,KAAK,SACdA,QAAAA,KAAK,MAAM,gBAAgB,EACzB,aACE,6JACJ,CAAC,CACH;CACA,cAAcA,QAAAA,KAAK,SACjBA,QAAAA,KAAK,MAAM,gBAAgB,EACzB,aAAa,qFACf,CAAC,CACH;CACA,iBAAiBA,QAAAA,KAAK,SACpBA,QAAAA,KAAK,MAAM,gBAAgB,EACzB,aAAa,kEACf,CAAC,CACH;CACA,OAAOA,QAAAA,KAAK,SAASA,QAAAA,KAAK,OAAO,EAAE,aAAa,oDAAoD,CAAC,CAAC;CACtG,UAAUA,QAAAA,KAAK,SACbA,QAAAA,KAAK,OAAOA,QAAAA,KAAK,OAAO,GAAGA,QAAAA,KAAK,QAAQ,GAAG,EACzC,aAAa,uDACf,CAAC,CACH;AACF,GACA,EAAE,sBAAsB,MAAM,CAChC;;AAGA,MAAa,uBAAuBA,QAAAA,KAAK,OACvC;CACE,IAAIA,QAAAA,KAAK,QAAQ,EAAE,aAAa,yCAAyC,CAAC;CAC1E,OAAOA,QAAAA,KAAK,OAAO,EAAE,aAAa,iCAAiC,CAAC;CACpE,aAAaA,QAAAA,KAAK,SAASC,8BAAAA,iBAAiB;CAC5C,cAAcD,QAAAA,KAAK,SAASA,QAAAA,KAAK,OAAO,EAAE,aAAa,sDAAsD,CAAC,CAAC;CAC/G,eAAeA,QAAAA,KAAK,SAClBA,QAAAA,KAAK,MAAMA,QAAAA,KAAK,OAAO,GAAG,EACxB,aAAa,yFACf,CAAC,CACH;CACA,eAAeA,QAAAA,KAAK,SAClBA,QAAAA,KAAK,OAAO,EAAE,aAAa,oEAAoE,CAAC,CAClG;CACA,OAAOA,QAAAA,KAAK,SAASA,QAAAA,KAAK,OAAO,EAAE,aAAa,wCAAwC,CAAC,CAAC;CAC1F,SAASA,QAAAA,KAAK,SACZA,QAAAA,KAAK,OAAO;EACV,MAAM,CAAC,GAAG,aAAa;EACvB,aAAa;CACf,CAAC,CACH;AACF,GACA,EAAE,sBAAsB,MAAM,CAChC;;;;;AAMA,MAAa,mBAAmBA,QAAAA,KAAK,OAAO;CAC1C,QAAQA,QAAAA,KAAK,OAAO,EAAE,MAAM,CAAC,GAAG,YAAY,EAAE,CAAC;CAC/C,OAAOA,QAAAA,KAAK,SACVA,QAAAA,KAAK,MAAM,gBAAgB;EACzB,UAAU;EACV,aACE;CACJ,CAAC,CACH;CACA,aAAaA,QAAAA,KAAK,SAChBA,QAAAA,KAAK,MAAM,sBAAsB;EAC/B,UAAU;EACV,aAAa;CACf,CAAC,CACH;CACA,IAAIA,QAAAA,KAAK,SACPA,QAAAA,KAAK,QAAQ,EACX,aACE,mIACJ,CAAC,CACH;CACA,QAAQA,QAAAA,KAAK,SACXA,QAAAA,KAAK,OAAO;EACV,MAAM,CAAC,GAAG,aAAa;EACvB,aAAa;CACf,CAAC,CACH;CACA,gBAAgBA,QAAAA,KAAK,SACnBA,QAAAA,KAAK,QAAQ,EAAE,aAAa,4DAA4D,CAAC,CAC3F;AACF,CAAC;;AAGD,MAAa,sBAAsB;CAAC;CAAU;CAAQ;CAAO;CAAU;AAAO;AAC9E,MAAM,EAAE,aAAa,cAAc,GAAG,yBAAyB,iBAAiB;AAChF,MAAa,yBAAyBA,QAAAA,KAAK,OAAO;CAChD,GAAG;CACH,QAAQA,QAAAA,KAAK,OAAO,EAAE,MAAM,CAAC,GAAG,mBAAmB,EAAE,CAAC;AACxD,CAAC"}

package/dist/task-giCbpKzV.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 { isDelegationActive as i, STORE_SCHEMA_VERSION as n, emptyDocument as r, DELETED_STATUS as t };
+
+//# sourceMappingURL=task-giCbpKzV.mjs.map

package/dist/task-giCbpKzV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-giCbpKzV.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/po-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/taskGraph-BOQvT0-M.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 { unresolvedBlockers as a, isTaskListComplete as i, detectCycle as n, isBlocked as r, deriveBlocks as t };
+
+//# sourceMappingURL=taskGraph-BOQvT0-M.mjs.map

package/dist/taskGraph-BOQvT0-M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph-BOQvT0-M.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"}

package/dist/taskGraph-BskRslrr.cjs

@@ -0,0 +1,92 @@
+//#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
+Object.defineProperty(exports, "deriveBlocks", {
+	enumerable: true,
+	get: function() {
+		return deriveBlocks;
+	}
+});
+Object.defineProperty(exports, "detectCycle", {
+	enumerable: true,
+	get: function() {
+		return detectCycle;
+	}
+});
+Object.defineProperty(exports, "isBlocked", {
+	enumerable: true,
+	get: function() {
+		return isBlocked;
+	}
+});
+Object.defineProperty(exports, "isTaskListComplete", {
+	enumerable: true,
+	get: function() {
+		return isTaskListComplete;
+	}
+});
+Object.defineProperty(exports, "unresolvedBlockers", {
+	enumerable: true,
+	get: function() {
+		return unresolvedBlockers;
+	}
+});
+
+//# sourceMappingURL=taskGraph-BskRslrr.cjs.map

package/dist/taskGraph-BskRslrr.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph-BskRslrr.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/taskGraph-D0zFHF2p.d.mts

@@ -0,0 +1,25 @@
+import { s as Task } from "./task-DJpTteeJ.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;
+/**
+ * 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;
+/** Inverse adjacency: for each task, which tasks list it in their blockedBy. */
+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.
+ */
+declare function unresolvedBlockers(taskList: readonly Task[], task: Task): number[];
+declare function isBlocked(taskList: readonly Task[], task: Task): boolean;
+//#endregion
+export { unresolvedBlockers as a, isTaskListComplete as i, detectCycle as n, isBlocked as r, deriveBlocks as t };
+//# sourceMappingURL=taskGraph-D0zFHF2p.d.mts.map

package/dist/taskGraph-D0zFHF2p.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph-D0zFHF2p.d.mts","names":[],"sources":["../src/models/taskGraph.ts"],"mappings":";;;iBAMgB,mBAAmB,mBAAmB;;;;;;;iBAWtC,YAAY,mBAAmB,QAAQ,gBAAgB;;iBA+BvD,aAAa,mBAAmB,SAAS;;;;;;;;iBAmBzC,mBAAmB,mBAAmB,QAAQ,MAAM;iBAQpD,UAAU,mBAAmB,QAAQ,MAAM"}