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

package/dist/src/services/reconcile/index.cjs

@@ -0,0 +1,65 @@
+const require_task = require("../../models/task.cjs");
+const require_index = require("../processLiveness/index.cjs");
+//#region src/services/reconcile/index.ts
+const ERR_ORPHANED_BY_RESTART = "Delegation orphaned by harness restart";
+const ERR_ORPHANED_BY_SESSION = "Delegation orphaned by session restart";
+/**
+* Recover tasks that no longer have anyone able to finish them.
+*
+* A subagent run dies with the harness that spawned it, but the store file
+* outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two
+* kinds of delegation qualify as dead:
+*
+* - the owning pid is gone, so nothing is left to report a result;
+* - the owning pid is *this* process, yet the request is absent from the live
+*   set. Settling requires an in-memory record, so an in-process session
+*   restart (which clears that map without writing to the store) leaves rows
+*   nothing can ever resolve. Checking pid liveness alone misses these, because
+*   the pid is our own and very much alive.
+*
+* Delegations owned by a different, still-running pid belong to a parallel
+* session and are left untouched.
+*/
+function reconcileOrphanedDelegations(document, now = (/* @__PURE__ */ new Date()).toISOString(), isAlive = require_index.isProcessAlive, self) {
+	const orphaned = [];
+	const tasks = document.tasks.map((task) => {
+		if (!require_task.isDelegationActive(task)) return task;
+		const pid = task.delegation?.pid;
+		if (pid === void 0) return task;
+		const abandonedHere = self !== void 0 && pid === self.pid && !self.liveRequestIds.has(task.delegation.requestId);
+		if (!abandonedHere && isAlive(pid)) return task;
+		const recovered = {
+			...task,
+			status: "pending",
+			updatedAt: now,
+			delegation: {
+				...task.delegation,
+				state: "failed",
+				endedAt: now,
+				result: {
+					status: "failed",
+					error: abandonedHere ? ERR_ORPHANED_BY_SESSION : ERR_ORPHANED_BY_RESTART
+				}
+			}
+		};
+		orphaned.push(recovered);
+		return recovered;
+	});
+	if (orphaned.length === 0) return {
+		document,
+		orphaned
+	};
+	return {
+		document: {
+			...document,
+			tasks
+		},
+		orphaned
+	};
+}
+//#endregion
+exports.ERR_ORPHANED_BY_RESTART = ERR_ORPHANED_BY_RESTART;
+exports.ERR_ORPHANED_BY_SESSION = ERR_ORPHANED_BY_SESSION;
+exports.reconcileOrphanedDelegations = reconcileOrphanedDelegations;
+
+//# sourceMappingURL=index.cjs.map

package/dist/src/services/reconcile/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["isProcessAlive","isDelegationActive"],"sources":["../../../../src/services/reconcile/index.ts"],"sourcesContent":["import { isDelegationActive, type Task, type TaskDocument } from '../../models/task';\nimport { isProcessAlive } from '../processLiveness';\n\nexport const ERR_ORPHANED_BY_RESTART = 'Delegation orphaned by harness restart';\nexport const ERR_ORPHANED_BY_SESSION = 'Delegation orphaned by session restart';\n\nexport interface ReconcileResult {\n  document: TaskDocument;\n  orphaned: Task[];\n}\n\n/** The delegations this process can still settle, used to spot its own leftovers. */\nexport interface ReconcileSelf {\n  pid: number;\n  liveRequestIds: ReadonlySet<string>;\n}\n\n/**\n * Recover tasks that no longer have anyone able to finish them.\n *\n * A subagent run dies with the harness that spawned it, but the store file\n * outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two\n * kinds of delegation qualify as dead:\n *\n * - the owning pid is gone, so nothing is left to report a result;\n * - the owning pid is *this* process, yet the request is absent from the live\n *   set. Settling requires an in-memory record, so an in-process session\n *   restart (which clears that map without writing to the store) leaves rows\n *   nothing can ever resolve. Checking pid liveness alone misses these, because\n *   the pid is our own and very much alive.\n *\n * Delegations owned by a different, still-running pid belong to a parallel\n * session and are left untouched.\n */\nexport function reconcileOrphanedDelegations(\n  document: TaskDocument,\n  now: string = new Date().toISOString(),\n  isAlive: (pid: number) => boolean = isProcessAlive,\n  self?: ReconcileSelf,\n): ReconcileResult {\n  const orphaned: Task[] = [];\n\n  const tasks = document.tasks.map((task) => {\n    if (!isDelegationActive(task)) return task;\n    const pid = task.delegation?.pid;\n    if (pid === undefined) return task;\n\n    const ownedByThisSession = self !== undefined && pid === self.pid;\n    const abandonedHere = ownedByThisSession && !self.liveRequestIds.has(task.delegation!.requestId);\n    if (!abandonedHere && isAlive(pid)) return task;\n\n    const recovered: Task = {\n      ...task,\n      status: 'pending',\n      updatedAt: now,\n      delegation: {\n        ...task.delegation!,\n        state: 'failed',\n        endedAt: now,\n        result: {\n          status: 'failed',\n          error: abandonedHere ? ERR_ORPHANED_BY_SESSION : ERR_ORPHANED_BY_RESTART,\n        },\n      },\n    };\n    orphaned.push(recovered);\n    return recovered;\n  });\n\n  if (orphaned.length === 0) return { document, orphaned };\n  return { document: { ...document, tasks }, orphaned };\n}\n"],"mappings":";;;AAGA,MAAa,0BAA0B;AACvC,MAAa,0BAA0B;;;;;;;;;;;;;;;;;;AA8BvC,SAAgB,6BACd,UACA,uBAAc,IAAI,KAAK,EAAA,CAAE,YAAY,GACrC,UAAoCA,cAAAA,gBACpC,MACiB;CACjB,MAAM,WAAmB,CAAC;CAE1B,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS;EACzC,IAAI,CAACC,aAAAA,mBAAmB,IAAI,GAAG,OAAO;EACtC,MAAM,MAAM,KAAK,YAAY;EAC7B,IAAI,QAAQ,KAAA,GAAW,OAAO;EAG9B,MAAM,gBADqB,SAAS,KAAA,KAAa,QAAQ,KAAK,OAClB,CAAC,KAAK,eAAe,IAAI,KAAK,WAAY,SAAS;EAC/F,IAAI,CAAC,iBAAiB,QAAQ,GAAG,GAAG,OAAO;EAE3C,MAAM,YAAkB;GACtB,GAAG;GACH,QAAQ;GACR,WAAW;GACX,YAAY;IACV,GAAG,KAAK;IACR,OAAO;IACP,SAAS;IACT,QAAQ;KACN,QAAQ;KACR,OAAO,gBAAgB,0BAA0B;IACnD;GACF;EACF;EACA,SAAS,KAAK,SAAS;EACvB,OAAO;CACT,CAAC;CAED,IAAI,SAAS,WAAW,GAAG,OAAO;EAAE;EAAU;CAAS;CACvD,OAAO;EAAE,UAAU;GAAE,GAAG;GAAU;EAAM;EAAG;CAAS;AACtD"}

package/dist/src/services/reconcile/index.d.cts

@@ -0,0 +1,33 @@
+import { Task, TaskDocument } from "../../models/task.cjs";
+//#region src/services/reconcile/index.d.ts
+export declare const ERR_ORPHANED_BY_RESTART = "Delegation orphaned by harness restart";
+export declare const ERR_ORPHANED_BY_SESSION = "Delegation orphaned by session restart";
+export interface ReconcileResult {
+  document: TaskDocument;
+  orphaned: Task[];
+}
+/** The delegations this process can still settle, used to spot its own leftovers. */
+export interface ReconcileSelf {
+  pid: number;
+  liveRequestIds: ReadonlySet<string>;
+}
+/**
+ * Recover tasks that no longer have anyone able to finish them.
+ *
+ * A subagent run dies with the harness that spawned it, but the store file
+ * outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two
+ * kinds of delegation qualify as dead:
+ *
+ * - the owning pid is gone, so nothing is left to report a result;
+ * - the owning pid is *this* process, yet the request is absent from the live
+ *   set. Settling requires an in-memory record, so an in-process session
+ *   restart (which clears that map without writing to the store) leaves rows
+ *   nothing can ever resolve. Checking pid liveness alone misses these, because
+ *   the pid is our own and very much alive.
+ *
+ * Delegations owned by a different, still-running pid belong to a parallel
+ * session and are left untouched.
+ */
+export declare function reconcileOrphanedDelegations(document: TaskDocument, now?: string, isAlive?: (pid: number) => boolean, self?: ReconcileSelf): ReconcileResult;
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/src/services/reconcile/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../../src/services/reconcile/index.ts"],"mappings":";;qBAGa;qBACA;iBAEI;EACf,UAAU;EACV,UAAU;;;iBAIK;EACf;EACA,gBAAgB;;;;;;;;;;;;;;;;;;;wBAoBF,6BACd,UAAU,cACV,cACA,WAAU,yBACV,OAAO,gBACN"}

package/dist/src/services/reconcile/index.d.mts

@@ -0,0 +1,33 @@
+import { Task, TaskDocument } from "../../models/task.mjs";
+//#region src/services/reconcile/index.d.ts
+export declare const ERR_ORPHANED_BY_RESTART = "Delegation orphaned by harness restart";
+export declare const ERR_ORPHANED_BY_SESSION = "Delegation orphaned by session restart";
+export interface ReconcileResult {
+  document: TaskDocument;
+  orphaned: Task[];
+}
+/** The delegations this process can still settle, used to spot its own leftovers. */
+export interface ReconcileSelf {
+  pid: number;
+  liveRequestIds: ReadonlySet<string>;
+}
+/**
+ * Recover tasks that no longer have anyone able to finish them.
+ *
+ * A subagent run dies with the harness that spawned it, but the store file
+ * outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two
+ * kinds of delegation qualify as dead:
+ *
+ * - the owning pid is gone, so nothing is left to report a result;
+ * - the owning pid is *this* process, yet the request is absent from the live
+ *   set. Settling requires an in-memory record, so an in-process session
+ *   restart (which clears that map without writing to the store) leaves rows
+ *   nothing can ever resolve. Checking pid liveness alone misses these, because
+ *   the pid is our own and very much alive.
+ *
+ * Delegations owned by a different, still-running pid belong to a parallel
+ * session and are left untouched.
+ */
+export declare function reconcileOrphanedDelegations(document: TaskDocument, now?: string, isAlive?: (pid: number) => boolean, self?: ReconcileSelf): ReconcileResult;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/src/services/reconcile/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../src/services/reconcile/index.ts"],"mappings":";;qBAGa;qBACA;iBAEI;EACf,UAAU;EACV,UAAU;;;iBAIK;EACf;EACA,gBAAgB;;;;;;;;;;;;;;;;;;;wBAoBF,6BACd,UAAU,cACV,cACA,WAAU,yBACV,OAAO,gBACN"}

package/dist/src/services/reconcile/index.mjs

@@ -0,0 +1,63 @@
+import { isDelegationActive } from "../../models/task.mjs";
+import { isProcessAlive } from "../processLiveness/index.mjs";
+//#region src/services/reconcile/index.ts
+const ERR_ORPHANED_BY_RESTART = "Delegation orphaned by harness restart";
+const ERR_ORPHANED_BY_SESSION = "Delegation orphaned by session restart";
+/**
+* Recover tasks that no longer have anyone able to finish them.
+*
+* A subagent run dies with the harness that spawned it, but the store file
+* outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two
+* kinds of delegation qualify as dead:
+*
+* - the owning pid is gone, so nothing is left to report a result;
+* - the owning pid is *this* process, yet the request is absent from the live
+*   set. Settling requires an in-memory record, so an in-process session
+*   restart (which clears that map without writing to the store) leaves rows
+*   nothing can ever resolve. Checking pid liveness alone misses these, because
+*   the pid is our own and very much alive.
+*
+* Delegations owned by a different, still-running pid belong to a parallel
+* session and are left untouched.
+*/
+function reconcileOrphanedDelegations(document, now = (/* @__PURE__ */ new Date()).toISOString(), isAlive = isProcessAlive, self) {
+	const orphaned = [];
+	const tasks = document.tasks.map((task) => {
+		if (!isDelegationActive(task)) return task;
+		const pid = task.delegation?.pid;
+		if (pid === void 0) return task;
+		const abandonedHere = self !== void 0 && pid === self.pid && !self.liveRequestIds.has(task.delegation.requestId);
+		if (!abandonedHere && isAlive(pid)) return task;
+		const recovered = {
+			...task,
+			status: "pending",
+			updatedAt: now,
+			delegation: {
+				...task.delegation,
+				state: "failed",
+				endedAt: now,
+				result: {
+					status: "failed",
+					error: abandonedHere ? ERR_ORPHANED_BY_SESSION : ERR_ORPHANED_BY_RESTART
+				}
+			}
+		};
+		orphaned.push(recovered);
+		return recovered;
+	});
+	if (orphaned.length === 0) return {
+		document,
+		orphaned
+	};
+	return {
+		document: {
+			...document,
+			tasks
+		},
+		orphaned
+	};
+}
+//#endregion
+export { ERR_ORPHANED_BY_RESTART, ERR_ORPHANED_BY_SESSION, reconcileOrphanedDelegations };
+
+//# sourceMappingURL=index.mjs.map

package/dist/src/services/reconcile/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/reconcile/index.ts"],"sourcesContent":["import { isDelegationActive, type Task, type TaskDocument } from '../../models/task';\nimport { isProcessAlive } from '../processLiveness';\n\nexport const ERR_ORPHANED_BY_RESTART = 'Delegation orphaned by harness restart';\nexport const ERR_ORPHANED_BY_SESSION = 'Delegation orphaned by session restart';\n\nexport interface ReconcileResult {\n  document: TaskDocument;\n  orphaned: Task[];\n}\n\n/** The delegations this process can still settle, used to spot its own leftovers. */\nexport interface ReconcileSelf {\n  pid: number;\n  liveRequestIds: ReadonlySet<string>;\n}\n\n/**\n * Recover tasks that no longer have anyone able to finish them.\n *\n * A subagent run dies with the harness that spawned it, but the store file\n * outlives both, so a crash leaves tasks stuck in `in_progress` forever. Two\n * kinds of delegation qualify as dead:\n *\n * - the owning pid is gone, so nothing is left to report a result;\n * - the owning pid is *this* process, yet the request is absent from the live\n *   set. Settling requires an in-memory record, so an in-process session\n *   restart (which clears that map without writing to the store) leaves rows\n *   nothing can ever resolve. Checking pid liveness alone misses these, because\n *   the pid is our own and very much alive.\n *\n * Delegations owned by a different, still-running pid belong to a parallel\n * session and are left untouched.\n */\nexport function reconcileOrphanedDelegations(\n  document: TaskDocument,\n  now: string = new Date().toISOString(),\n  isAlive: (pid: number) => boolean = isProcessAlive,\n  self?: ReconcileSelf,\n): ReconcileResult {\n  const orphaned: Task[] = [];\n\n  const tasks = document.tasks.map((task) => {\n    if (!isDelegationActive(task)) return task;\n    const pid = task.delegation?.pid;\n    if (pid === undefined) return task;\n\n    const ownedByThisSession = self !== undefined && pid === self.pid;\n    const abandonedHere = ownedByThisSession && !self.liveRequestIds.has(task.delegation!.requestId);\n    if (!abandonedHere && isAlive(pid)) return task;\n\n    const recovered: Task = {\n      ...task,\n      status: 'pending',\n      updatedAt: now,\n      delegation: {\n        ...task.delegation!,\n        state: 'failed',\n        endedAt: now,\n        result: {\n          status: 'failed',\n          error: abandonedHere ? ERR_ORPHANED_BY_SESSION : ERR_ORPHANED_BY_RESTART,\n        },\n      },\n    };\n    orphaned.push(recovered);\n    return recovered;\n  });\n\n  if (orphaned.length === 0) return { document, orphaned };\n  return { document: { ...document, tasks }, orphaned };\n}\n"],"mappings":";;;AAGA,MAAa,0BAA0B;AACvC,MAAa,0BAA0B;;;;;;;;;;;;;;;;;;AA8BvC,SAAgB,6BACd,UACA,uBAAc,IAAI,KAAK,EAAA,CAAE,YAAY,GACrC,UAAoC,gBACpC,MACiB;CACjB,MAAM,WAAmB,CAAC;CAE1B,MAAM,QAAQ,SAAS,MAAM,KAAK,SAAS;EACzC,IAAI,CAAC,mBAAmB,IAAI,GAAG,OAAO;EACtC,MAAM,MAAM,KAAK,YAAY;EAC7B,IAAI,QAAQ,KAAA,GAAW,OAAO;EAG9B,MAAM,gBADqB,SAAS,KAAA,KAAa,QAAQ,KAAK,OAClB,CAAC,KAAK,eAAe,IAAI,KAAK,WAAY,SAAS;EAC/F,IAAI,CAAC,iBAAiB,QAAQ,GAAG,GAAG,OAAO;EAE3C,MAAM,YAAkB;GACtB,GAAG;GACH,QAAQ;GACR,WAAW;GACX,YAAY;IACV,GAAG,KAAK;IACR,OAAO;IACP,SAAS;IACT,QAAQ;KACN,QAAQ;KACR,OAAO,gBAAgB,0BAA0B;IACnD;GACF;EACF;EACA,SAAS,KAAK,SAAS;EACvB,OAAO;CACT,CAAC;CAED,IAAI,SAAS,WAAW,GAAG,OAAO;EAAE;EAAU;CAAS;CACvD,OAAO;EAAE,UAAU;GAAE,GAAG;GAAU;EAAM;EAAG;CAAS;AACtD"}

package/dist/src/services/reducer/index.cjs

@@ -0,0 +1,350 @@
+const require_taskGraph = require("../../models/taskGraph.cjs");
+const require_task = require("../../models/task.cjs");
+const require_index = require("../invariants/index.cjs");
+//#region src/services/reducer/index.ts
+/** Default board capacity when a caller does not provide a configured limit. */
+const DEFAULT_REDUCER_MAX_TASKS = 15;
+/** Bounds the work one call can do, and with it the size of one committed write. */
+const MAX_UPSERT_ITEMS = 100;
+/**
+* A ref must start with a letter, which makes it structurally unconfusable with
+* a stringified id. That is why resolving a dependency token is just a `typeof`
+* check with no coercion heuristics.
+*/
+const REF_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
+/**
+* Does this op represent state that must reach disk?
+*
+* The exhaustive switch is the point: a future `Op` variant cannot be added
+* without declaring its persistence intent, so nothing silently starts or stops
+* bumping `rev`.
+*/
+function isCommittingOp(op) {
+	switch (op.kind) {
+		case "error":
+		case "list":
+		case "get": return false;
+		case "upsert": return op.items.some((item) => item.kind === "created" || item.kind === "updated");
+		case "delete":
+		case "clear": return true;
+	}
+}
+/** Joined per-item failures, for the thrown error when an upsert applied nothing. */
+function formatUpsertFailure(op) {
+	return op.items.filter((item) => item.kind === "failed").map((item) => `item[${item.index}]: ${item.message}`).join("\n");
+}
+/** The single item's outcome, for callers that only ever send a batch of one. */
+function singleItemOutcome(op) {
+	return op.kind === "upsert" ? op.items[0] : void 0;
+}
+function errorResult(document, message) {
+	return {
+		document,
+		op: {
+			kind: "error",
+			message
+		}
+	};
+}
+function sameNumberList(a, b) {
+	const x = a ?? [];
+	const y = b ?? [];
+	return x.length === y.length && x.every((value, index) => value === y[index]);
+}
+function sameRecord(a, b) {
+	return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+/**
+* Did this update change anything? A no-effect update (status re-set to its
+* current value, fields re-sent unchanged) reports "No change" rather than
+* "Updated #N" — without the distinction a model can loop re-issuing the same
+* call believing it never landed.
+*/
+function taskChanged(before, after) {
+	return before.subject !== after.subject || before.status !== after.status || before.description !== after.description || before.activeForm !== after.activeForm || before.owner !== after.owner || !sameNumberList(before.blockedBy, after.blockedBy) || !sameRecord(before.metadata, after.metadata);
+}
+function withTasks(document, tasks, nextId = document.nextId) {
+	return {
+		...document,
+		tasks,
+		nextId
+	};
+}
+/** Merge incoming metadata over a base; a `null` value deletes its key. */
+function mergeMetadata(base, incoming) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(incoming)) if (value === null) delete merged[key];
+	else merged[key] = value;
+	return Object.keys(merged).length ? merged : void 0;
+}
+/** Copy the optional scalar fields an item may set onto a task, in place. */
+function assignScalars(target, item) {
+	if (item.subject !== void 0) target.subject = item.subject;
+	if (item.description !== void 0) target.description = item.description;
+	if (item.activeForm !== void 0) target.activeForm = item.activeForm;
+	if (item.owner !== void 0) target.owner = item.owner;
+	if (item.metadata !== void 0) {
+		const merged = mergeMetadata(target.metadata, item.metadata);
+		if (merged === void 0) delete target.metadata;
+		else target.metadata = merged;
+	}
+}
+function resolveDep(context, field, token) {
+	if (typeof token === "number") return {
+		ok: true,
+		id: token
+	};
+	if (!REF_PATTERN.test(token)) return {
+		ok: false,
+		message: `${field}: "${token}" is not a valid ref; pass an existing task id as a number`
+	};
+	const id = context.refIds.get(token);
+	if (id !== void 0) return {
+		ok: true,
+		id
+	};
+	const failedAt = context.failedRefs.get(token);
+	if (failedAt !== void 0) return {
+		ok: false,
+		message: `${field}: ref "${token}" refers to item[${failedAt}], which failed`
+	};
+	return {
+		ok: false,
+		message: `${field}: unknown ref "${token}" — a ref must be declared by an earlier entry in the same call`
+	};
+}
+function fail(message) {
+	return {
+		ok: false,
+		message
+	};
+}
+/** Structural checks that apply to every entry, whichever kind it is. */
+function checkShape(context, item) {
+	if (item.ref !== void 0) {
+		if (item.id !== void 0) return "ref is only valid when creating a task; drop the id, or drop the ref";
+		if (!REF_PATTERN.test(item.ref)) return `ref "${item.ref}" is invalid: a ref must start with a letter and contain only letters, digits, - or _`;
+		if (context.refIds.get(item.ref) !== void 0 || context.failedRefs.has(item.ref)) return `duplicate ref "${item.ref}": it was already declared by an earlier entry`;
+	}
+}
+function applyCreateItem(context, item, index, now) {
+	if (item.subject === void 0) return fail("subject is required when the entry has no id");
+	if (!item.subject.trim()) return fail("subject must not be blank");
+	if (item.addBlockedBy !== void 0 || item.removeBlockedBy !== void 0) return fail("addBlockedBy / removeBlockedBy are only for an entry with an id; a new task uses blockedBy");
+	if (item.status === "deleted") return fail("cannot create a task with status deleted; create it, then use action delete");
+	if (context.tasks.filter((task) => task.status !== "deleted").length >= context.maxTasks) return fail(`task limit of ${context.maxTasks} reached; delete completed tasks first before creating new tasks`);
+	const blockedBy = [];
+	for (const token of item.blockedBy ?? []) {
+		const resolved = resolveDep(context, "blockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		const dep = context.tasks.find((task) => task.id === resolved.id);
+		if (!dep) return fail(`blockedBy: #${resolved.id} not found`);
+		if (dep.status === "deleted") return fail(`blockedBy: #${resolved.id} is deleted`);
+		if (!blockedBy.includes(resolved.id)) blockedBy.push(resolved.id);
+	}
+	const created = {
+		id: context.nextId,
+		subject: item.subject,
+		status: item.status ?? "pending",
+		createdAt: now,
+		updatedAt: now
+	};
+	assignScalars(created, item);
+	if (blockedBy.length) created.blockedBy = blockedBy;
+	context.nextId += 1;
+	context.tasks.push(created);
+	if (item.ref) context.refIds.set(item.ref, created.id);
+	return {
+		ok: true,
+		outcome: {
+			index,
+			kind: "created",
+			id: created.id,
+			subject: created.subject,
+			status: created.status,
+			...item.ref ? { ref: item.ref } : {},
+			...blockedBy.length ? { blockedBy } : {}
+		}
+	};
+}
+function applyUpdateItem(context, item, index, now) {
+	const id = item.id;
+	const at = context.tasks.findIndex((task) => task.id === id);
+	if (at === -1) return fail(`#${id} not found`);
+	if (item.blockedBy !== void 0) return fail("blockedBy is only for a new entry; use addBlockedBy / removeBlockedBy on an entry that has an id");
+	if (!(item.subject !== void 0 || item.description !== void 0 || item.activeForm !== void 0 || item.status !== void 0 || item.owner !== void 0 || item.metadata !== void 0 || Boolean(item.addBlockedBy?.length) || Boolean(item.removeBlockedBy?.length))) return fail("nothing to change: provide at least one of subject, description, activeForm, status, owner, metadata, addBlockedBy, or removeBlockedBy");
+	const current = context.tasks[at];
+	if (item.subject !== void 0 && !item.subject.trim()) return fail("subject must not be blank");
+	let newStatus = current.status;
+	if (item.status !== void 0) {
+		if (!require_index.isTransitionValid(current.status, item.status)) return fail(`illegal transition ${current.status} -> ${item.status}`);
+		newStatus = item.status;
+	}
+	let newBlockedBy = current.blockedBy ? [...current.blockedBy] : [];
+	for (const token of item.removeBlockedBy ?? []) {
+		const resolved = resolveDep(context, "removeBlockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		newBlockedBy = newBlockedBy.filter((dep) => dep !== resolved.id);
+	}
+	for (const token of item.addBlockedBy ?? []) {
+		const resolved = resolveDep(context, "addBlockedBy", token);
+		if (!resolved.ok) return fail(resolved.message);
+		if (resolved.id === id) return fail(`cannot block #${id} on itself`);
+		const dep = context.tasks.find((task) => task.id === resolved.id);
+		if (!dep) return fail(`addBlockedBy: #${resolved.id} not found`);
+		if (dep.status === "deleted") return fail(`addBlockedBy: #${resolved.id} is deleted`);
+		if (!newBlockedBy.includes(resolved.id)) newBlockedBy.push(resolved.id);
+	}
+	const updated = {
+		...current,
+		status: newStatus
+	};
+	assignScalars(updated, item);
+	if (newBlockedBy.length) updated.blockedBy = newBlockedBy;
+	else delete updated.blockedBy;
+	const candidate = [...context.tasks];
+	candidate[at] = updated;
+	if (item.addBlockedBy?.length && require_taskGraph.detectCycle(candidate, id, newBlockedBy)) return fail("addBlockedBy would create a cycle in the blockedBy graph");
+	const changed = taskChanged(current, updated);
+	if (changed) updated.updatedAt = now;
+	context.tasks = candidate;
+	return {
+		ok: true,
+		outcome: changed ? {
+			index,
+			kind: "updated",
+			id,
+			fromStatus: current.status,
+			toStatus: newStatus
+		} : {
+			index,
+			kind: "unchanged",
+			id,
+			status: newStatus
+		}
+	};
+}
+/**
+* Apply every entry in request order, threading the document.
+*
+* Each entry lands completely or not at all: a create whose dependencies fail
+* is not kept dependency-free, because handing back an unblocked task the
+* caller asked to be blocked is a lie it may immediately act on.
+*/
+function applyUpsert(document, items, now, maxTasks) {
+	const context = {
+		tasks: [...document.tasks],
+		nextId: document.nextId,
+		maxTasks,
+		refIds: /* @__PURE__ */ new Map(),
+		failedRefs: /* @__PURE__ */ new Map()
+	};
+	const outcomes = [];
+	let applied = 0;
+	for (const [index, item] of items.entries()) {
+		const shapeError = checkShape(context, item);
+		const result = shapeError ? fail(shapeError) : item.id === void 0 ? applyCreateItem(context, item, index, now) : applyUpdateItem(context, item, index, now);
+		if (result.ok) {
+			outcomes.push(result.outcome);
+			applied += 1;
+			continue;
+		}
+		if (item.ref && REF_PATTERN.test(item.ref) && !context.refIds.has(item.ref)) context.failedRefs.set(item.ref, index);
+		outcomes.push({
+			index,
+			kind: "failed",
+			message: result.message,
+			...item.id === void 0 ? {} : { id: item.id },
+			...item.ref ? { ref: item.ref } : {}
+		});
+	}
+	return {
+		document: applied > 0 ? withTasks(document, context.tasks, context.nextId) : document,
+		op: {
+			kind: "upsert",
+			items: outcomes,
+			applied,
+			failed: outcomes.length - applied
+		}
+	};
+}
+/**
+* Pure reducer: (document, action, params) -> (document, op).
+*
+* All validation is in-line: structural guards plus state-aware checks
+* (transition legality, dangling or deleted blockedBy, self-block, cycles,
+* in-flight delegations). The caller owns persistence and formatting.
+*/
+function applyTaskMutation(document, action, params, now = (/* @__PURE__ */ new Date()).toISOString(), maxTasks = DEFAULT_REDUCER_MAX_TASKS) {
+	switch (action) {
+		case "upsert": {
+			const items = params.tasks;
+			if (!Array.isArray(items) || items.length === 0) return errorResult(document, "upsert requires a non-empty tasks array, e.g. {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Write tests\"}]}");
+			if (items.length > 100) return errorResult(document, `upsert accepts at most 100 entries per call (received ${items.length})`);
+			return applyUpsert(document, items, now, maxTasks);
+		}
+		case "list": return {
+			document,
+			op: {
+				kind: "list",
+				includeDeleted: params.includeDeleted === true,
+				...params.status !== void 0 ? { statusFilter: params.status } : {}
+			}
+		};
+		case "get": {
+			if (params.id === void 0) return errorResult(document, "id required for get");
+			const task = document.tasks.find((candidate) => candidate.id === params.id);
+			if (!task) return errorResult(document, `#${params.id} not found`);
+			return {
+				document,
+				op: {
+					kind: "get",
+					task
+				}
+			};
+		}
+		case "delete": {
+			if (params.id === void 0) return errorResult(document, "id required for delete");
+			const index = document.tasks.findIndex((task) => task.id === params.id);
+			if (index === -1) return errorResult(document, `#${params.id} not found`);
+			const current = document.tasks[index];
+			if (current.status === "deleted") return errorResult(document, `#${current.id} is already deleted`);
+			if (require_task.isDelegationActive(current)) return errorResult(document, `#${current.id} has a running delegation — cancel it before deleting`);
+			const tasks = [...document.tasks];
+			tasks[index] = {
+				...current,
+				status: require_task.DELETED_STATUS,
+				updatedAt: now
+			};
+			return {
+				document: withTasks(document, tasks),
+				op: {
+					kind: "delete",
+					id: current.id,
+					subject: current.subject
+				}
+			};
+		}
+		case "clear": {
+			const active = document.tasks.filter(require_task.isDelegationActive);
+			if (active.length > 0) return errorResult(document, `cannot clear while delegations are running (${active.map((task) => `#${task.id}`).join(", ")}) — cancel them first`);
+			const count = document.tasks.length;
+			return {
+				document: withTasks(document, [], 1),
+				op: {
+					kind: "clear",
+					count
+				}
+			};
+		}
+	}
+}
+//#endregion
+exports.MAX_UPSERT_ITEMS = MAX_UPSERT_ITEMS;
+exports.REF_PATTERN = REF_PATTERN;
+exports.applyTaskMutation = applyTaskMutation;
+exports.formatUpsertFailure = formatUpsertFailure;
+exports.isCommittingOp = isCommittingOp;
+exports.singleItemOutcome = singleItemOutcome;
+
+//# sourceMappingURL=index.cjs.map

package/dist/src/services/reducer/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["isTransitionValid","detectCycle","isDelegationActive","DELETED_STATUS"],"sources":["../../../../src/services/reducer/index.ts"],"sourcesContent":["import {\n  DELETED_STATUS,\n  type DepToken,\n  isDelegationActive,\n  type Task,\n  type TaskAction,\n  type TaskDocument,\n  type TaskItemMutation,\n  type TaskMutationParams,\n  type TaskStatus,\n  type UpsertItemOutcome,\n} from '../../models/task';\nimport { detectCycle } from '../../models/taskGraph';\nimport { isTransitionValid } from '../invariants';\n\n/** Default board capacity when a caller does not provide a configured limit. */\nconst DEFAULT_REDUCER_MAX_TASKS = 15;\n\n/** Bounds the work one call can do, and with it the size of one committed write. */\nexport const MAX_UPSERT_ITEMS = 100;\n\n/**\n * A ref must start with a letter, which makes it structurally unconfusable with\n * a stringified id. That is why resolving a dependency token is just a `typeof`\n * check with no coercion heuristics.\n */\nexport const REF_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;\n\n/**\n * Reducer outcome. Closed tagged union: adding an action requires extending\n * this union and the response formatter, which the compiler enforces.\n *\n * `upsert` carries one outcome per request item. It is returned even when every\n * item failed — `error` is reserved for whole-call faults — so the tool layer\n * still has the per-item messages to report.\n */\nexport type Op =\n  | { kind: 'upsert'; items: UpsertItemOutcome[]; applied: number; failed: number }\n  | { kind: 'delete'; id: number; subject: string }\n  | { kind: 'list'; statusFilter?: TaskStatus; includeDeleted: boolean }\n  | { kind: 'get'; task: Task }\n  | { kind: 'clear'; count: number }\n  | { kind: 'error'; message: string };\n\nexport interface ApplyResult {\n  document: TaskDocument;\n  op: Op;\n}\n\n/** Actions the reducer owns. `assign`/`cancel` are handled by the delegation manager. */\nexport type ReducerAction = Exclude<TaskAction, 'assign' | 'cancel'>;\n\n/**\n * Does this op represent state that must reach disk?\n *\n * The exhaustive switch is the point: a future `Op` variant cannot be added\n * without declaring its persistence intent, so nothing silently starts or stops\n * bumping `rev`.\n */\nexport function isCommittingOp(op: Op): boolean {\n  switch (op.kind) {\n    case 'error':\n    case 'list':\n    case 'get':\n      return false;\n    case 'upsert':\n      return op.items.some((item) => item.kind === 'created' || item.kind === 'updated');\n    case 'delete':\n    case 'clear':\n      return true;\n  }\n}\n\n/** Joined per-item failures, for the thrown error when an upsert applied nothing. */\nexport function formatUpsertFailure(op: Extract<Op, { kind: 'upsert' }>): string {\n  return op.items\n    .filter((item) => item.kind === 'failed')\n    .map((item) => `item[${item.index}]: ${item.message}`)\n    .join('\\n');\n}\n\n/** The single item's outcome, for callers that only ever send a batch of one. */\nexport function singleItemOutcome(op: Op): UpsertItemOutcome | undefined {\n  return op.kind === 'upsert' ? op.items[0] : undefined;\n}\n\nfunction errorResult(document: TaskDocument, message: string): ApplyResult {\n  return { document, op: { kind: 'error', message } };\n}\n\nfunction sameNumberList(a: number[] | undefined, b: number[] | undefined): boolean {\n  const x = a ?? [];\n  const y = b ?? [];\n  return x.length === y.length && x.every((value, index) => value === y[index]);\n}\n\nfunction sameRecord(a: Record<string, unknown> | undefined, b: Record<string, unknown> | undefined): boolean {\n  return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);\n}\n\n/**\n * Did this update change anything? A no-effect update (status re-set to its\n * current value, fields re-sent unchanged) reports \"No change\" rather than\n * \"Updated #N\" — without the distinction a model can loop re-issuing the same\n * call believing it never landed.\n */\nfunction taskChanged(before: Task, after: Task): boolean {\n  return (\n    before.subject !== after.subject ||\n    before.status !== after.status ||\n    before.description !== after.description ||\n    before.activeForm !== after.activeForm ||\n    before.owner !== after.owner ||\n    !sameNumberList(before.blockedBy, after.blockedBy) ||\n    !sameRecord(before.metadata, after.metadata)\n  );\n}\n\nfunction withTasks(document: TaskDocument, tasks: Task[], nextId = document.nextId): TaskDocument {\n  return { ...document, tasks, nextId };\n}\n\n/** Merge incoming metadata over a base; a `null` value deletes its key. */\nfunction mergeMetadata(\n  base: Record<string, unknown> | undefined,\n  incoming: Record<string, unknown>,\n): Record<string, unknown> | undefined {\n  const merged: Record<string, unknown> = { ...base };\n  for (const [key, value] of Object.entries(incoming)) {\n    if (value === null) delete merged[key];\n    else merged[key] = value;\n  }\n  return Object.keys(merged).length ? merged : undefined;\n}\n\n/** Copy the optional scalar fields an item may set onto a task, in place. */\nfunction assignScalars(target: Task, item: TaskItemMutation): void {\n  if (item.subject !== undefined) target.subject = item.subject;\n  if (item.description !== undefined) target.description = item.description;\n  if (item.activeForm !== undefined) target.activeForm = item.activeForm;\n  if (item.owner !== undefined) target.owner = item.owner;\n  if (item.metadata !== undefined) {\n    const merged = mergeMetadata(target.metadata, item.metadata);\n    if (merged === undefined) delete target.metadata;\n    else target.metadata = merged;\n  }\n}\n\n/**\n * Working state threaded item to item, so entry N observes every effect of\n * entries 1..N-1. `refIds` and `failedRefs` are what make the cascade work:\n * refs resolve backward only, so an entry that names a failed sibling is always\n * processed after the failure that killed it.\n */\ninterface UpsertContext {\n  tasks: Task[];\n  nextId: number;\n  maxTasks: number;\n  refIds: Map<string, number>;\n  failedRefs: Map<string, number>;\n}\n\ntype Resolved = { ok: true; id: number } | { ok: false; message: string };\n\nfunction resolveDep(context: UpsertContext, field: string, token: DepToken): Resolved {\n  if (typeof token === 'number') return { ok: true, id: token };\n  if (!REF_PATTERN.test(token)) {\n    return { ok: false, message: `${field}: \"${token}\" is not a valid ref; pass an existing task id as a number` };\n  }\n  const id = context.refIds.get(token);\n  if (id !== undefined) return { ok: true, id };\n  const failedAt = context.failedRefs.get(token);\n  if (failedAt !== undefined) {\n    return { ok: false, message: `${field}: ref \"${token}\" refers to item[${failedAt}], which failed` };\n  }\n  return {\n    ok: false,\n    message: `${field}: unknown ref \"${token}\" — a ref must be declared by an earlier entry in the same call`,\n  };\n}\n\ntype ItemResult = { ok: true; outcome: UpsertItemOutcome } | { ok: false; message: string };\n\nfunction fail(message: string): ItemResult {\n  return { ok: false, message };\n}\n\n/** Structural checks that apply to every entry, whichever kind it is. */\nfunction checkShape(context: UpsertContext, item: TaskItemMutation): string | undefined {\n  if (item.ref !== undefined) {\n    if (item.id !== undefined) return 'ref is only valid when creating a task; drop the id, or drop the ref';\n    if (!REF_PATTERN.test(item.ref)) {\n      return `ref \"${item.ref}\" is invalid: a ref must start with a letter and contain only letters, digits, - or _`;\n    }\n    const owner = context.refIds.get(item.ref) !== undefined || context.failedRefs.has(item.ref);\n    if (owner) return `duplicate ref \"${item.ref}\": it was already declared by an earlier entry`;\n  }\n  return undefined;\n}\n\nfunction applyCreateItem(context: UpsertContext, item: TaskItemMutation, index: number, now: string): ItemResult {\n  if (item.subject === undefined) return fail('subject is required when the entry has no id');\n  if (!item.subject.trim()) return fail('subject must not be blank');\n  if (item.addBlockedBy !== undefined || item.removeBlockedBy !== undefined) {\n    return fail('addBlockedBy / removeBlockedBy are only for an entry with an id; a new task uses blockedBy');\n  }\n  // A task created as a tombstone is invisible to every view and can never\n  // leave `deleted`, so it would be a write-only black hole.\n  if (item.status === DELETED_STATUS) {\n    return fail('cannot create a task with status deleted; create it, then use action delete');\n  }\n\n  const taskCount = context.tasks.filter((task) => task.status !== DELETED_STATUS).length;\n  if (taskCount >= context.maxTasks) {\n    return fail(`task limit of ${context.maxTasks} reached; delete completed tasks first before creating new tasks`);\n  }\n\n  const blockedBy: number[] = [];\n  for (const token of item.blockedBy ?? []) {\n    const resolved = resolveDep(context, 'blockedBy', token);\n    if (!resolved.ok) return fail(resolved.message);\n    const dep = context.tasks.find((task) => task.id === resolved.id);\n    if (!dep) return fail(`blockedBy: #${resolved.id} not found`);\n    if (dep.status === DELETED_STATUS) return fail(`blockedBy: #${resolved.id} is deleted`);\n    if (!blockedBy.includes(resolved.id)) blockedBy.push(resolved.id);\n  }\n\n  // No cycle check is needed: the id is freshly allocated, so nothing already\n  // in the document can point at it yet.\n  const created: Task = {\n    id: context.nextId,\n    subject: item.subject,\n    status: item.status ?? 'pending',\n    createdAt: now,\n    updatedAt: now,\n  };\n  assignScalars(created, item);\n  if (blockedBy.length) created.blockedBy = blockedBy;\n\n  context.nextId += 1;\n  context.tasks.push(created);\n  if (item.ref) context.refIds.set(item.ref, created.id);\n\n  return {\n    ok: true,\n    outcome: {\n      index,\n      kind: 'created',\n      id: created.id,\n      subject: created.subject,\n      status: created.status,\n      ...(item.ref ? { ref: item.ref } : {}),\n      ...(blockedBy.length ? { blockedBy } : {}),\n    },\n  };\n}\n\nfunction applyUpdateItem(context: UpsertContext, item: TaskItemMutation, index: number, now: string): ItemResult {\n  const id = item.id as number;\n  const at = context.tasks.findIndex((task) => task.id === id);\n  if (at === -1) return fail(`#${id} not found`);\n  if (item.blockedBy !== undefined) {\n    return fail('blockedBy is only for a new entry; use addBlockedBy / removeBlockedBy on an entry that has an id');\n  }\n\n  const hasMutation =\n    item.subject !== undefined ||\n    item.description !== undefined ||\n    item.activeForm !== undefined ||\n    item.status !== undefined ||\n    item.owner !== undefined ||\n    item.metadata !== undefined ||\n    Boolean(item.addBlockedBy?.length) ||\n    Boolean(item.removeBlockedBy?.length);\n  if (!hasMutation) {\n    return fail(\n      'nothing to change: provide at least one of subject, description, activeForm, status, owner, metadata, addBlockedBy, or removeBlockedBy',\n    );\n  }\n\n  const current = context.tasks[at];\n\n  // The Task Space overlay commits free text from an inline editor, so a blank\n  // subject reaches the reducer as a real update rather than as a missing\n  // field. Persisting it would leave an unidentifiable row.\n  if (item.subject !== undefined && !item.subject.trim()) return fail('subject must not be blank');\n\n  let newStatus = current.status;\n  if (item.status !== undefined) {\n    if (!isTransitionValid(current.status, item.status)) {\n      return fail(`illegal transition ${current.status} -> ${item.status}`);\n    }\n    newStatus = item.status;\n  }\n\n  let newBlockedBy = current.blockedBy ? [...current.blockedBy] : [];\n  for (const token of item.removeBlockedBy ?? []) {\n    const resolved = resolveDep(context, 'removeBlockedBy', token);\n    if (!resolved.ok) return fail(resolved.message);\n    // Removing an id that is not there is a well-defined no-op, so unlike the\n    // add path this deliberately skips the existence check.\n    newBlockedBy = newBlockedBy.filter((dep) => dep !== resolved.id);\n  }\n  for (const token of item.addBlockedBy ?? []) {\n    const resolved = resolveDep(context, 'addBlockedBy', token);\n    if (!resolved.ok) return fail(resolved.message);\n    if (resolved.id === id) return fail(`cannot block #${id} on itself`);\n    const dep = context.tasks.find((task) => task.id === resolved.id);\n    if (!dep) return fail(`addBlockedBy: #${resolved.id} not found`);\n    if (dep.status === DELETED_STATUS) return fail(`addBlockedBy: #${resolved.id} is deleted`);\n    if (!newBlockedBy.includes(resolved.id)) newBlockedBy.push(resolved.id);\n  }\n\n  const updated: Task = { ...current, status: newStatus };\n  assignScalars(updated, item);\n  if (newBlockedBy.length) updated.blockedBy = newBlockedBy;\n  else delete updated.blockedBy;\n\n  // The candidate is written before the check because `detectCycle` unions the\n  // node's stored edges with the ones passed in: checking against the old array\n  // would resurrect an edge `removeBlockedBy` just stripped and reject a\n  // remove+add that legitimately breaks a cycle.\n  const candidate = [...context.tasks];\n  candidate[at] = updated;\n  if (item.addBlockedBy?.length && detectCycle(candidate, id, newBlockedBy)) {\n    return fail('addBlockedBy would create a cycle in the blockedBy graph');\n  }\n\n  const changed = taskChanged(current, updated);\n  if (changed) updated.updatedAt = now;\n  context.tasks = candidate;\n\n  return {\n    ok: true,\n    outcome: changed\n      ? { index, kind: 'updated', id, fromStatus: current.status, toStatus: newStatus }\n      : { index, kind: 'unchanged', id, status: newStatus },\n  };\n}\n\n/**\n * Apply every entry in request order, threading the document.\n *\n * Each entry lands completely or not at all: a create whose dependencies fail\n * is not kept dependency-free, because handing back an unblocked task the\n * caller asked to be blocked is a lie it may immediately act on.\n */\nfunction applyUpsert(document: TaskDocument, items: TaskItemMutation[], now: string, maxTasks: number): ApplyResult {\n  const context: UpsertContext = {\n    tasks: [...document.tasks],\n    nextId: document.nextId,\n    maxTasks,\n    refIds: new Map(),\n    failedRefs: new Map(),\n  };\n  const outcomes: UpsertItemOutcome[] = [];\n  let applied = 0;\n\n  for (const [index, item] of items.entries()) {\n    const shapeError = checkShape(context, item);\n    const result = shapeError\n      ? fail(shapeError)\n      : item.id === undefined\n        ? applyCreateItem(context, item, index, now)\n        : applyUpdateItem(context, item, index, now);\n\n    if (result.ok) {\n      outcomes.push(result.outcome);\n      applied += 1;\n      continue;\n    }\n    // A ref whose owner failed must not read as a typo to the entries that\n    // depend on it, so the dead ref is recorded rather than left unknown.\n    if (item.ref && REF_PATTERN.test(item.ref) && !context.refIds.has(item.ref)) {\n      context.failedRefs.set(item.ref, index);\n    }\n    outcomes.push({\n      index,\n      kind: 'failed',\n      message: result.message,\n      ...(item.id === undefined ? {} : { id: item.id }),\n      ...(item.ref ? { ref: item.ref } : {}),\n    });\n  }\n\n  return {\n    // Nothing applied means nothing to write: returning the original object by\n    // reference keeps the caller's write-skip path identical to a hard error.\n    document: applied > 0 ? withTasks(document, context.tasks, context.nextId) : document,\n    op: { kind: 'upsert', items: outcomes, applied, failed: outcomes.length - applied },\n  };\n}\n\n/**\n * Pure reducer: (document, action, params) -> (document, op).\n *\n * All validation is in-line: structural guards plus state-aware checks\n * (transition legality, dangling or deleted blockedBy, self-block, cycles,\n * in-flight delegations). The caller owns persistence and formatting.\n */\nexport function applyTaskMutation(\n  document: TaskDocument,\n  action: ReducerAction,\n  params: TaskMutationParams,\n  now: string = new Date().toISOString(),\n  maxTasks = DEFAULT_REDUCER_MAX_TASKS,\n): ApplyResult {\n  switch (action) {\n    case 'upsert': {\n      const items = params.tasks;\n      if (!Array.isArray(items) || items.length === 0) {\n        return errorResult(\n          document,\n          'upsert requires a non-empty tasks array, e.g. {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Write tests\"}]}',\n        );\n      }\n      if (items.length > MAX_UPSERT_ITEMS) {\n        return errorResult(\n          document,\n          `upsert accepts at most ${MAX_UPSERT_ITEMS} entries per call (received ${items.length})`,\n        );\n      }\n      return applyUpsert(document, items, now, maxTasks);\n    }\n\n    case 'list': {\n      return {\n        document,\n        op: {\n          kind: 'list',\n          includeDeleted: params.includeDeleted === true,\n          ...(params.status !== undefined ? { statusFilter: params.status } : {}),\n        },\n      };\n    }\n\n    case 'get': {\n      if (params.id === undefined) return errorResult(document, 'id required for get');\n      const task = document.tasks.find((candidate) => candidate.id === params.id);\n      if (!task) return errorResult(document, `#${params.id} not found`);\n      return { document, op: { kind: 'get', task } };\n    }\n\n    case 'delete': {\n      if (params.id === undefined) return errorResult(document, 'id required for delete');\n      const index = document.tasks.findIndex((task) => task.id === params.id);\n      if (index === -1) return errorResult(document, `#${params.id} not found`);\n      const current = document.tasks[index];\n      if (current.status === DELETED_STATUS) return errorResult(document, `#${current.id} is already deleted`);\n      if (isDelegationActive(current)) {\n        return errorResult(document, `#${current.id} has a running delegation — cancel it before deleting`);\n      }\n\n      const tasks = [...document.tasks];\n      tasks[index] = { ...current, status: DELETED_STATUS, updatedAt: now };\n      return {\n        document: withTasks(document, tasks),\n        op: { kind: 'delete', id: current.id, subject: current.subject },\n      };\n    }\n\n    case 'clear': {\n      const active = document.tasks.filter(isDelegationActive);\n      if (active.length > 0) {\n        const ids = active.map((task) => `#${task.id}`).join(', ');\n        return errorResult(document, `cannot clear while delegations are running (${ids}) — cancel them first`);\n      }\n      const count = document.tasks.length;\n      return {\n        document: withTasks(document, [], 1),\n        op: { kind: 'clear', count },\n      };\n    }\n  }\n}\n"],"mappings":"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"}