@agimon-ai/doompi-task 0.0.1-alpha.9 → 0.0.1-alpha.91

package/dist/{tui/selectors.d.cts → selectors-DPDPPjH3.d.mts}

@@ -1,5 +1,5 @@
-import { Task } from "../store/types.cjs";
-//#region src/tui/selectors.d.ts
+import { s as Task } from "./task-hLh4BOO7.mjs";
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.ts
 interface TaskCounts {
   total: number;
   completed: number;
@@ -46,8 +46,15 @@ interface OverlayLayout {
   hiddenCompleted: number;
   truncatedTail: number;
 }
+/**
+ * Choose which rows fit the overlay budget.
+ *
+ * Active work wins limited space: in-progress first, then failed, blocked, and
+ * pending. Selected rows are always returned in source order, however, so a
+ * status update does not reshuffle an otherwise unchanged overlay.
+ */
 declare function selectOverlayLayoutFromProjection(projection: TaskProjection, budget: number): OverlayLayout;
 declare function selectOverlayLayout(tasks: readonly Task[], budget: number): OverlayLayout;
 //#endregion
-export { OverlayLayout, TaskCounts, TaskGroups, TaskProjection, countTasks, deriveTaskProjection, groupTasks, hasActiveWork, selectOverlayLayout, selectOverlayLayoutFromProjection, shouldShowIds, visibleTasks };
-//# sourceMappingURL=selectors.d.cts.map
+export { countTasks as a, hasActiveWork as c, shouldShowIds as d, visibleTasks as f, TaskProjection as i, selectOverlayLayout as l, TaskCounts as n, deriveTaskProjection as o, TaskGroups as r, groupTasks as s, OverlayLayout as t, selectOverlayLayoutFromProjection as u };
+//# sourceMappingURL=selectors-DPDPPjH3.d.mts.map

package/dist/selectors-DPDPPjH3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-DPDPPjH3.d.mts","names":[],"sources":["../src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts"],"mappings":";;UAGiB;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf,YAAY;EACZ,SAAS;EACT,SAAS;EACT,WAAW;EACX,QAAQ;;UAGO;EACf,SAAS;EACT,QAAQ;EACR,QAAQ;EACR;EACA;;iBAGc,aAAa,gBAAgB,SAAS;;;;;;;iBAuBtC,qBAAqB,gBAAgB,SAAS;iBA4C9C,WAAW,gBAAgB,SAAS;;;;;;;iBAUpC,WAAW,gBAAgB,SAAS;;iBAKpC,cAAc,gBAAgB;iBAI9B,cAAc,gBAAgB;UAI7B;EACf,SAAS;EACT;EACA;;;;;;;;;iBAUc,kCAAkC,YAAY,gBAAgB,iBAAiB;iBAiC/E,oBAAoB,gBAAgB,QAAQ,iBAAiB"}

package/dist/selectors-b-69vb4W.cjs

@@ -0,0 +1,189 @@
+const require_invariants = require("./invariants-DhjEjBPU.cjs");
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts
+function visibleTasks(tasks) {
+	return require_invariants.canonicalizeTasks(tasks).filter((task) => task.status !== "deleted");
+}
+function indexStatuses(tasks) {
+	return new Map(tasks.map((task) => [task.id, task.status]));
+}
+function hasUnresolvedBlocker(task, statuses) {
+	return task.blockedBy?.some((id) => {
+		const status = statuses.get(id);
+		return status !== void 0 && status !== "completed" && status !== "deleted";
+	}) ?? false;
+}
+/**
+* Derive all overlay-facing state in O(tasks + dependency edges).
+*
+* The id index replaces one full task-list scan per dependency, while the
+* ordered pass keeps group ordering identical to the source document.
+*/
+function deriveTaskProjection(tasks) {
+	const canonical = require_invariants.canonicalizeTasks(tasks);
+	const statuses = indexStatuses(canonical);
+	const visible = [];
+	const counts = {
+		total: 0,
+		completed: 0,
+		inProgress: 0,
+		pending: 0,
+		failed: 0,
+		blocked: 0
+	};
+	const groups = {
+		inProgress: [],
+		blocked: [],
+		pending: [],
+		completed: [],
+		failed: []
+	};
+	let showIds = false;
+	for (const task of canonical) {
+		if (task.status === "deleted") continue;
+		visible.push(task);
+		counts.total += 1;
+		showIds ||= Boolean(task.blockedBy?.length);
+		switch (task.status) {
+			case "in_progress":
+				counts.inProgress += 1;
+				groups.inProgress.push(task);
+				break;
+			case "pending":
+				counts.pending += 1;
+				if (hasUnresolvedBlocker(task, statuses)) {
+					counts.blocked += 1;
+					groups.blocked.push(task);
+				} else groups.pending.push(task);
+				break;
+			case "failed":
+				counts.failed += 1;
+				groups.failed.push(task);
+				break;
+			case "completed":
+				counts.completed += 1;
+				groups.completed.push(task);
+		}
+	}
+	return {
+		visible,
+		counts,
+		groups,
+		showIds,
+		hasActiveWork: counts.inProgress > 0
+	};
+}
+function countTasks(tasks) {
+	return deriveTaskProjection(tasks).counts;
+}
+/**
+* Group tasks for display.
+*
+* Blocked tasks split out of `pending` because a reader scanning the overlay
+* needs to know at a glance what is actually actionable right now.
+*/
+function groupTasks(tasks) {
+	return deriveTaskProjection(tasks).groups;
+}
+/** Ids are only worth the visual noise once dependencies are in play. */
+function shouldShowIds(tasks) {
+	return tasks.some((task) => task.status !== "deleted" && Boolean(task.blockedBy?.length));
+}
+function hasActiveWork(tasks) {
+	return tasks.some((task) => task.status === "in_progress");
+}
+/**
+* Choose which rows fit the overlay budget.
+*
+* Active work wins limited space: in-progress first, then failed, blocked, and
+* pending. Selected rows are always returned in source order, however, so a
+* status update does not reshuffle an otherwise unchanged overlay.
+*/
+function selectOverlayLayoutFromProjection(projection, budget) {
+	const { groups, visible: sourceOrder } = projection;
+	const active = [
+		...groups.inProgress,
+		...groups.failed,
+		...groups.blocked,
+		...groups.pending
+	];
+	if (budget <= 0) return {
+		visible: [],
+		hiddenCompleted: groups.completed.length,
+		truncatedTail: active.length
+	};
+	if (sourceOrder.length <= budget) return {
+		visible: sourceOrder,
+		hiddenCompleted: 0,
+		truncatedTail: 0
+	};
+	if (active.length <= budget) {
+		const remaining = budget - active.length;
+		const shownCompleted = groups.completed.slice(0, remaining);
+		const selected = /* @__PURE__ */ new Set([...active, ...shownCompleted]);
+		return {
+			visible: sourceOrder.filter((task) => selected.has(task)),
+			hiddenCompleted: groups.completed.length - shownCompleted.length,
+			truncatedTail: 0
+		};
+	}
+	const selected = new Set(active.slice(0, budget));
+	return {
+		visible: sourceOrder.filter((task) => selected.has(task)),
+		hiddenCompleted: groups.completed.length,
+		truncatedTail: active.length - budget
+	};
+}
+function selectOverlayLayout(tasks, budget) {
+	return selectOverlayLayoutFromProjection(deriveTaskProjection(tasks), budget);
+}
+//#endregion
+Object.defineProperty(exports, "countTasks", {
+	enumerable: true,
+	get: function() {
+		return countTasks;
+	}
+});
+Object.defineProperty(exports, "deriveTaskProjection", {
+	enumerable: true,
+	get: function() {
+		return deriveTaskProjection;
+	}
+});
+Object.defineProperty(exports, "groupTasks", {
+	enumerable: true,
+	get: function() {
+		return groupTasks;
+	}
+});
+Object.defineProperty(exports, "hasActiveWork", {
+	enumerable: true,
+	get: function() {
+		return hasActiveWork;
+	}
+});
+Object.defineProperty(exports, "selectOverlayLayout", {
+	enumerable: true,
+	get: function() {
+		return selectOverlayLayout;
+	}
+});
+Object.defineProperty(exports, "selectOverlayLayoutFromProjection", {
+	enumerable: true,
+	get: function() {
+		return selectOverlayLayoutFromProjection;
+	}
+});
+Object.defineProperty(exports, "shouldShowIds", {
+	enumerable: true,
+	get: function() {
+		return shouldShowIds;
+	}
+});
+Object.defineProperty(exports, "visibleTasks", {
+	enumerable: true,
+	get: function() {
+		return visibleTasks;
+	}
+});
+
+//# sourceMappingURL=selectors-b-69vb4W.cjs.map

package/dist/selectors-b-69vb4W.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors-b-69vb4W.cjs","names":["canonicalizeTasks"],"sources":["../src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts"],"sourcesContent":["import type { Task } from '../../../../../../models/task';\nimport { canonicalizeTasks } from '../../../../../../services/invariants';\n\nexport interface TaskCounts {\n  total: number;\n  completed: number;\n  inProgress: number;\n  pending: number;\n  failed: number;\n  blocked: number;\n}\n\nexport interface TaskGroups {\n  inProgress: Task[];\n  blocked: Task[];\n  pending: Task[];\n  completed: Task[];\n  failed: Task[];\n}\n\nexport interface TaskProjection {\n  visible: Task[];\n  counts: TaskCounts;\n  groups: TaskGroups;\n  showIds: boolean;\n  hasActiveWork: boolean;\n}\n\nexport function visibleTasks(tasks: readonly Task[]): Task[] {\n  return canonicalizeTasks(tasks).filter((task) => task.status !== 'deleted');\n}\n\nfunction indexStatuses(tasks: readonly Task[]): Map<number, Task['status']> {\n  return new Map(tasks.map((task) => [task.id, task.status]));\n}\n\nfunction hasUnresolvedBlocker(task: Task, statuses: ReadonlyMap<number, Task['status']>): boolean {\n  return (\n    task.blockedBy?.some((id) => {\n      const status = statuses.get(id);\n      return status !== undefined && status !== 'completed' && status !== 'deleted';\n    }) ?? false\n  );\n}\n\n/**\n * Derive all overlay-facing state in O(tasks + dependency edges).\n *\n * The id index replaces one full task-list scan per dependency, while the\n * ordered pass keeps group ordering identical to the source document.\n */\nexport function deriveTaskProjection(tasks: readonly Task[]): TaskProjection {\n  const canonical = canonicalizeTasks(tasks);\n  const statuses = indexStatuses(canonical);\n  const visible: Task[] = [];\n  const counts: TaskCounts = { total: 0, completed: 0, inProgress: 0, pending: 0, failed: 0, blocked: 0 };\n  const groups: TaskGroups = { inProgress: [], blocked: [], pending: [], completed: [], failed: [] };\n  let showIds = false;\n\n  for (const task of canonical) {\n    if (task.status === 'deleted') continue;\n\n    visible.push(task);\n    counts.total += 1;\n    showIds ||= Boolean(task.blockedBy?.length);\n\n    switch (task.status) {\n      case 'in_progress':\n        counts.inProgress += 1;\n        groups.inProgress.push(task);\n        break;\n      case 'pending': {\n        counts.pending += 1;\n        if (hasUnresolvedBlocker(task, statuses)) {\n          counts.blocked += 1;\n          groups.blocked.push(task);\n        } else {\n          groups.pending.push(task);\n        }\n        break;\n      }\n      case 'failed':\n        counts.failed += 1;\n        groups.failed.push(task);\n        break;\n      case 'completed':\n        counts.completed += 1;\n        groups.completed.push(task);\n        break;\n    }\n  }\n\n  return { visible, counts, groups, showIds, hasActiveWork: counts.inProgress > 0 };\n}\n\nexport function countTasks(tasks: readonly Task[]): TaskCounts {\n  return deriveTaskProjection(tasks).counts;\n}\n\n/**\n * Group tasks for display.\n *\n * Blocked tasks split out of `pending` because a reader scanning the overlay\n * needs to know at a glance what is actually actionable right now.\n */\nexport function groupTasks(tasks: readonly Task[]): TaskGroups {\n  return deriveTaskProjection(tasks).groups;\n}\n\n/** Ids are only worth the visual noise once dependencies are in play. */\nexport function shouldShowIds(tasks: readonly Task[]): boolean {\n  return tasks.some((task) => task.status !== 'deleted' && Boolean(task.blockedBy?.length));\n}\n\nexport function hasActiveWork(tasks: readonly Task[]): boolean {\n  return tasks.some((task) => task.status === 'in_progress');\n}\n\nexport interface OverlayLayout {\n  visible: Task[];\n  hiddenCompleted: number;\n  truncatedTail: number;\n}\n\n/**\n * Choose which rows fit the overlay budget.\n *\n * Active work wins limited space: in-progress first, then failed, blocked, and\n * pending. Selected rows are always returned in source order, however, so a\n * status update does not reshuffle an otherwise unchanged overlay.\n */\nexport function selectOverlayLayoutFromProjection(projection: TaskProjection, budget: number): OverlayLayout {\n  const { groups, visible: sourceOrder } = projection;\n  const active = [...groups.inProgress, ...groups.failed, ...groups.blocked, ...groups.pending];\n  if (budget <= 0) {\n    return {\n      visible: [],\n      hiddenCompleted: groups.completed.length,\n      truncatedTail: active.length,\n    };\n  }\n  if (sourceOrder.length <= budget) {\n    return { visible: sourceOrder, hiddenCompleted: 0, truncatedTail: 0 };\n  }\n\n  if (active.length <= budget) {\n    const remaining = budget - active.length;\n    const shownCompleted = groups.completed.slice(0, remaining);\n    const selected = new Set([...active, ...shownCompleted]);\n    return {\n      visible: sourceOrder.filter((task) => selected.has(task)),\n      hiddenCompleted: groups.completed.length - shownCompleted.length,\n      truncatedTail: 0,\n    };\n  }\n\n  const selected = new Set(active.slice(0, budget));\n  return {\n    visible: sourceOrder.filter((task) => selected.has(task)),\n    hiddenCompleted: groups.completed.length,\n    truncatedTail: active.length - budget,\n  };\n}\n\nexport function selectOverlayLayout(tasks: readonly Task[], budget: number): OverlayLayout {\n  return selectOverlayLayoutFromProjection(deriveTaskProjection(tasks), budget);\n}\n"],"mappings":"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"}

package/dist/storeInvariants.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_invariants = require("./invariants-DhjEjBPU.cjs");
+exports.VALID_TRANSITIONS = require_invariants.VALID_TRANSITIONS;
+exports.canonicalizeTasks = require_invariants.canonicalizeTasks;
+exports.isTransitionValid = require_invariants.isTransitionValid;

package/dist/storeInvariants.d.mts

@@ -0,0 +1,23 @@
+import { h as TaskStatus, s as Task } from "./task-hLh4BOO7.mjs";
+//#region src/services/invariants/index.d.ts
+/**
+ * Collapse a malformed snapshot to one row per task id.
+ *
+ * Normal writes replace tasks in place, but older or externally edited stores
+ * can contain both a stale and a current copy. Prefer the copy with the newest
+ * ISO update timestamp; equal or missing timestamps use the later array entry.
+ * The winning row keeps the id's original position so repair does not reorder
+ * an otherwise stable task list.
+ */
+export declare function canonicalizeTasks(tasks: readonly Task[]): Task[];
+/**
+ * Allowed forward transitions per source status.
+ *
+ * `failed` is recoverable (a delegation can be retried) so it may return to
+ * pending or in_progress. `completed` is one-way to `deleted`; `deleted` is a
+ * terminal tombstone.
+ */
+export declare const VALID_TRANSITIONS: Record<TaskStatus, ReadonlySet<TaskStatus>>;
+export declare function isTransitionValid(from: TaskStatus, to: TaskStatus): boolean;
+//#endregion
+//# sourceMappingURL=storeInvariants.d.mts.map

package/dist/storeInvariants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeInvariants.d.mts","names":[],"sources":["../src/services/invariants/index.ts"],"mappings":";;;;;;;;;;;wBAWgB,kBAAkB,gBAAgB,SAAS;;;;;;;;qBA4B9C,mBAAmB,OAAO,YAAY,YAAY;wBAQ/C,kBAAkB,MAAM,YAAY,IAAI"}

package/dist/storeInvariants.mjs

@@ -0,0 +1,2 @@
+import { n as canonicalizeTasks, r as isTransitionValid, t as VALID_TRANSITIONS } from "./invariants-q_UamF7D.mjs";
+export { VALID_TRANSITIONS, canonicalizeTasks, isTransitionValid };

package/dist/storePaths.cjs

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_paths = require("./paths-BsFVRulr.cjs");
+exports.STORE_PATH_ENV = require_paths.STORE_PATH_ENV;
+exports.hasStorePathOverride = require_paths.hasStorePathOverride;
+exports.lockPathFor = require_paths.lockPathFor;
+exports.removeLegacyStoreDirectory = require_paths.removeLegacyStoreDirectory;
+exports.removeLegacyStoreDirectoryAsync = require_paths.removeLegacyStoreDirectoryAsync;
+exports.resolveLegacyStoreDirectory = require_paths.resolveLegacyStoreDirectory;
+exports.resolveLegacyStoreDirectoryAsync = require_paths.resolveLegacyStoreDirectoryAsync;
+exports.resolveSessionKey = require_paths.resolveSessionKey;
+exports.resolveStorePath = require_paths.resolveStorePath;
+exports.sweepStoreFiles = require_paths.sweepStoreFiles;
+exports.sweepStoreFilesAsync = require_paths.sweepStoreFilesAsync;
+exports.tempPathFor = require_paths.tempPathFor;

package/dist/storePaths.d.mts

@@ -0,0 +1,2 @@
+import { a as removeLegacyStoreDirectory, c as resolveLegacyStoreDirectoryAsync, d as sweepStoreFiles, f as sweepStoreFilesAsync, i as lockPathFor, l as resolveSessionKey, n as StoreSweepResult, o as removeLegacyStoreDirectoryAsync, p as tempPathFor, r as hasStorePathOverride, s as resolveLegacyStoreDirectory, t as STORE_PATH_ENV, u as resolveStorePath } from "./index-XY9VPmfm.mjs";
+export { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor };

package/dist/storePaths.mjs

@@ -0,0 +1,2 @@
+import { a as removeLegacyStoreDirectoryAsync, c as resolveSessionKey, d as sweepStoreFilesAsync, f as tempPathFor, i as removeLegacyStoreDirectory, l as resolveStorePath, n as hasStorePathOverride, o as resolveLegacyStoreDirectory, r as lockPathFor, s as resolveLegacyStoreDirectoryAsync, t as STORE_PATH_ENV, u as sweepStoreFiles } from "./paths-Bg8EEbk1.mjs";
+export { STORE_PATH_ENV, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor };

package/dist/storeProcessLiveness.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_processLiveness = require("./processLiveness-umpNgsPR.cjs");
+exports.isProcessAlive = require_processLiveness.isProcessAlive;

package/dist/{store/processLiveness.d.mts → storeProcessLiveness.d.mts}

@@ -1,4 +1,4 @@
-//#region src/store/processLiveness.d.ts
+//#region src/services/processLiveness/index.d.ts
 /**
  * Is a process still running?
  *
@@ -6,7 +6,6 @@
  * signal. EPERM means the process exists but belongs to another user, which
  * still counts as alive.
  */
-declare function isProcessAlive(pid: number): boolean;
+export declare function isProcessAlive(pid: number): boolean;
 //#endregion
-export { isProcessAlive };
-//# sourceMappingURL=processLiveness.d.mts.map
+//# sourceMappingURL=storeProcessLiveness.d.mts.map

package/dist/storeProcessLiveness.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeProcessLiveness.d.mts","names":[],"sources":["../src/services/processLiveness/index.ts"],"mappings":";;;;;;;;wBAOgB,eAAe"}

package/dist/storeProcessLiveness.mjs

@@ -0,0 +1,2 @@
+import { t as isProcessAlive } from "./processLiveness-Ccd9wenT.mjs";
+export { isProcessAlive };

package/dist/storeReconcile.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_reconcile = require("./reconcile-cRL0NjDr.cjs");
+exports.ERR_ORPHANED_BY_RESTART = require_reconcile.ERR_ORPHANED_BY_RESTART;
+exports.ERR_ORPHANED_BY_SESSION = require_reconcile.ERR_ORPHANED_BY_SESSION;
+exports.reconcileOrphanedDelegations = require_reconcile.reconcileOrphanedDelegations;

package/dist/storeReconcile.d.mts

@@ -0,0 +1,2 @@
+import { a as reconcileOrphanedDelegations, i as ReconcileSelf, n as ERR_ORPHANED_BY_SESSION, r as ReconcileResult, t as ERR_ORPHANED_BY_RESTART } from "./index-BNMm9g0K.mjs";
+export { ERR_ORPHANED_BY_RESTART, ERR_ORPHANED_BY_SESSION, ReconcileResult, ReconcileSelf, reconcileOrphanedDelegations };

package/dist/storeReconcile.mjs

@@ -0,0 +1,2 @@
+import { n as ERR_ORPHANED_BY_SESSION, r as reconcileOrphanedDelegations, t as ERR_ORPHANED_BY_RESTART } from "./reconcile-BcD-hTbd.mjs";
+export { ERR_ORPHANED_BY_RESTART, ERR_ORPHANED_BY_SESSION, reconcileOrphanedDelegations };

package/dist/storeReducer.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_reducer = require("./reducer-BV0YIZ2o.cjs");
+exports.MAX_UPSERT_ITEMS = require_reducer.MAX_UPSERT_ITEMS;
+exports.REF_PATTERN = require_reducer.REF_PATTERN;
+exports.applyTaskMutation = require_reducer.applyTaskMutation;
+exports.formatUpsertFailure = require_reducer.formatUpsertFailure;
+exports.isCommittingOp = require_reducer.isCommittingOp;
+exports.singleItemOutcome = require_reducer.singleItemOutcome;

package/dist/storeReducer.d.mts

@@ -0,0 +1,2 @@
+import { a as ReducerAction, c as isCommittingOp, i as REF_PATTERN, l as singleItemOutcome, n as MAX_UPSERT_ITEMS, o as applyTaskMutation, r as Op, s as formatUpsertFailure, t as ApplyResult } from "./index-DIpc6_uJ.mjs";
+export { ApplyResult, MAX_UPSERT_ITEMS, Op, REF_PATTERN, ReducerAction, applyTaskMutation, formatUpsertFailure, isCommittingOp, singleItemOutcome };

package/dist/storeReducer.mjs

@@ -0,0 +1,2 @@
+import { a as isCommittingOp, i as formatUpsertFailure, n as REF_PATTERN, o as singleItemOutcome, r as applyTaskMutation, t as MAX_UPSERT_ITEMS } from "./reducer-BEfJFM5L.mjs";
+export { MAX_UPSERT_ITEMS, REF_PATTERN, applyTaskMutation, formatUpsertFailure, isCommittingOp, singleItemOutcome };

package/dist/storeTaskGraph.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_taskGraph = require("./taskGraph-BskRslrr.cjs");
+exports.deriveBlocks = require_taskGraph.deriveBlocks;
+exports.detectCycle = require_taskGraph.detectCycle;
+exports.isBlocked = require_taskGraph.isBlocked;
+exports.isTaskListComplete = require_taskGraph.isTaskListComplete;
+exports.unresolvedBlockers = require_taskGraph.unresolvedBlockers;

package/dist/storeTaskGraph.d.mts

@@ -0,0 +1,2 @@
+import { a as unresolvedBlockers, i as isTaskListComplete, n as detectCycle, r as isBlocked, t as deriveBlocks } from "./taskGraph-YQXCfXTn.mjs";
+export { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };

package/dist/storeTaskGraph.mjs

@@ -0,0 +1,2 @@
+import { a as unresolvedBlockers, i as isTaskListComplete, n as detectCycle, r as isBlocked, t as deriveBlocks } from "./taskGraph-BOQvT0-M.mjs";
+export { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };

package/dist/storeTaskStore.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_taskStore = require("./taskStore-T1pPy-UJ.cjs");
+exports.TaskStore = require_taskStore.TaskStore;

package/dist/storeTaskStore.d.mts

@@ -0,0 +1,2 @@
+import { n as TaskStoreCommitListener, r as TaskStoreOptions, t as TaskStore } from "./index-B7oVjSey.mjs";
+export { TaskStore, TaskStoreCommitListener, TaskStoreOptions };

package/dist/storeTaskStore.mjs

@@ -0,0 +1,2 @@
+import { t as TaskStore } from "./taskStore-CFx12KJk.mjs";
+export { TaskStore };

package/dist/storeTypes.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_task = require("./task-CXF9VULl.cjs");
+exports.DELETED_STATUS = require_task.DELETED_STATUS;
+exports.STORE_SCHEMA_VERSION = require_task.STORE_SCHEMA_VERSION;
+exports.emptyDocument = require_task.emptyDocument;
+exports.isDelegationActive = require_task.isDelegationActive;

package/dist/storeTypes.d.mts

@@ -0,0 +1,2 @@
+import { _ as UpsertSummary, a as DepToken, c as TaskAction, d as TaskDetails, f as TaskDocument, g as UpsertItemOutcome, h as TaskStatus, i as DelegationState, l as TaskAssignment, m as TaskMutationParams, n as DELETED_STATUS, o as STORE_SCHEMA_VERSION, p as TaskItemMutation, r as DelegationResult, s as Task, t as AssignmentSummary, u as TaskDelegation, v as emptyDocument, y as isDelegationActive } from "./task-hLh4BOO7.mjs";
+export { AssignmentSummary, DELETED_STATUS, DelegationResult, DelegationState, DepToken, STORE_SCHEMA_VERSION, Task, TaskAction, TaskAssignment, TaskDelegation, TaskDetails, TaskDocument, TaskItemMutation, TaskMutationParams, TaskStatus, UpsertItemOutcome, UpsertSummary, emptyDocument, isDelegationActive };

package/dist/storeTypes.mjs

@@ -0,0 +1,2 @@
+import { i as isDelegationActive, n as STORE_SCHEMA_VERSION, r as emptyDocument, t as DELETED_STATUS } from "./task-giCbpKzV.mjs";
+export { DELETED_STATUS, STORE_SCHEMA_VERSION, emptyDocument, isDelegationActive };

package/dist/task-B4aF5J9s.mjs

@@ -0,0 +1,6 @@
+//#region src/constants/task.ts
+const COMMAND_NAME = "tasks";
+//#endregion
+export { COMMAND_NAME as t };
+
+//# sourceMappingURL=task-B4aF5J9s.mjs.map

package/dist/task-B4aF5J9s.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-B4aF5J9s.mjs","names":[],"sources":["../src/constants/task.ts"],"sourcesContent":["export const COMMAND_NAME = 'tasks';\n"],"mappings":";AAAA,MAAa,eAAe"}

package/dist/task-CXF9VULl.cjs

@@ -0,0 +1,49 @@
+//#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
+Object.defineProperty(exports, "DELETED_STATUS", {
+	enumerable: true,
+	get: function() {
+		return DELETED_STATUS;
+	}
+});
+Object.defineProperty(exports, "STORE_SCHEMA_VERSION", {
+	enumerable: true,
+	get: function() {
+		return STORE_SCHEMA_VERSION;
+	}
+});
+Object.defineProperty(exports, "emptyDocument", {
+	enumerable: true,
+	get: function() {
+		return emptyDocument;
+	}
+});
+Object.defineProperty(exports, "isDelegationActive", {
+	enumerable: true,
+	get: function() {
+		return isDelegationActive;
+	}
+});
+
+//# sourceMappingURL=task-CXF9VULl.cjs.map

package/dist/task-CXF9VULl.cjs.map

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

package/dist/task-CkFjC3Fo.d.mts

@@ -0,0 +1,5 @@
+//#region src/constants/task.d.ts
+declare const COMMAND_NAME = "tasks";
+//#endregion
+export { COMMAND_NAME as t };
+//# sourceMappingURL=task-CkFjC3Fo.d.mts.map

package/dist/task-CkFjC3Fo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-CkFjC3Fo.d.mts","names":[],"sources":["../src/constants/task.ts"],"mappings":";cAAa"}

package/dist/{tool/schema.d.cts → task-DHSvdK6E.d.mts}

@@ -1,12 +1,11 @@
-import { TaskAction } from "../store/types.cjs";
+import { c as TaskAction } from "./task-hLh4BOO7.mjs";
 import { Static, Type } from "typebox";
-//#region src/tool/schema.d.ts
-declare const TASK_ACTIONS: readonly ["upsert", "list", "get", "delete", "clear", "assign", "cancel"];
-declare const TASK_STATUSES: readonly ["pending", "in_progress", "completed", "failed", "deleted"];
-declare const TASK_CONTEXTS: readonly ["fresh", "fork"];
+//#region src/schemas/task.d.ts
+declare const TASK_ACTIONS: readonly ['upsert', 'list', 'get', 'delete', 'clear', 'assign', 'cancel'];
+declare const TASK_STATUSES: readonly ['pending', 'in_progress', 'completed', 'failed', 'deleted'];
+declare const TASK_CONTEXTS: readonly ['fresh', 'fork'];
 declare const TOOL_NAME = "task";
 declare const TOOL_LABEL = "Task";
-declare const COMMAND_NAME = "tasks";
 declare const ERR_REQUIRES_INTERACTIVE = "/tasks requires interactive mode";
 declare const MSG_NO_TASKS = "No tasks yet. Ask the agent to add some!";
 /**
@@ -23,7 +22,7 @@ declare const TASK_ACTION_FIELDS: {
   readonly get: readonly ["action", "id"];
   readonly delete: readonly ["action", "id"];
   readonly clear: readonly ["action"];
-  readonly assign: readonly ["action", "id", "agent", "inlineAgent", "instructions", "relevantFiles", "priorFindings", "model", "context"];
+  readonly assign: readonly ["action", "assignments"];
   readonly cancel: readonly ["action", "id"];
 };
 declare function taskActionAcceptsField(action: TaskAction, field: string): boolean;
@@ -47,6 +46,19 @@ declare const TaskItemSchema: Type.TObject<{
   owner: Type.TOptional<Type.TString>;
   metadata: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
 }>;
+/** One task-to-agent handoff in a native assignment batch. */
+declare const TaskAssignmentSchema: Type.TObject<{
+  id: Type.TInteger;
+  agent: Type.TString;
+  inlineAgent: Type.TOptional<Type.TObject<{
+    systemPrompt: Type.TString;
+  }>>;
+  instructions: Type.TOptional<Type.TString>;
+  relevantFiles: Type.TOptional<Type.TArray<Type.TString>>;
+  priorFindings: Type.TOptional<Type.TString>;
+  model: Type.TOptional<Type.TString>;
+  context: Type.TOptional<Type.TString>;
+}>;
 /**
  * Tool parameters. Every `description` doubles as LLM-facing prompt copy, so
  * wording changes here change model behaviour.
@@ -66,21 +78,25 @@ declare const TaskParamsSchema: Type.TObject<{
     owner: Type.TOptional<Type.TString>;
     metadata: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
   }>>>;
+  assignments: Type.TOptional<Type.TArray<Type.TObject<{
+    id: Type.TInteger;
+    agent: Type.TString;
+    inlineAgent: Type.TOptional<Type.TObject<{
+      systemPrompt: Type.TString;
+    }>>;
+    instructions: Type.TOptional<Type.TString>;
+    relevantFiles: Type.TOptional<Type.TArray<Type.TString>>;
+    priorFindings: Type.TOptional<Type.TString>;
+    model: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TString>;
+  }>>>;
   id: Type.TOptional<Type.TInteger>;
   status: Type.TOptional<Type.TString>;
   includeDeleted: Type.TOptional<Type.TBoolean>;
-  agent: Type.TOptional<Type.TString>;
-  inlineAgent: Type.TOptional<Type.TObject<{
-    systemPrompt: Type.TString;
-  }>>;
-  instructions: Type.TOptional<Type.TString>;
-  relevantFiles: Type.TOptional<Type.TArray<Type.TString>>;
-  priorFindings: Type.TOptional<Type.TString>;
-  model: Type.TOptional<Type.TString>;
-  context: Type.TOptional<Type.TString>;
 }>;
 type TaskItemParams = Static<typeof TaskItemSchema>;
+type TaskAssignmentParams = Static<typeof TaskAssignmentSchema>;
 type TaskParams = Static<typeof TaskParamsSchema>;
 //#endregion
-export { COMMAND_NAME, ERR_REQUIRES_INTERACTIVE, MSG_NO_TASKS, MSG_UPSERT_FIELD_MISPLACED, TASK_ACTIONS, TASK_ACTION_FIELDS, TASK_CONTEXTS, TASK_STATUSES, TOOL_LABEL, TOOL_NAME, TaskItemParams, TaskItemSchema, TaskParams, TaskParamsSchema, taskActionAcceptsField };
-//# sourceMappingURL=schema.d.cts.map
+export { TASK_ACTION_FIELDS as a, TOOL_LABEL as c, TaskAssignmentSchema as d, TaskItemParams as f, taskActionAcceptsField as g, TaskParamsSchema as h, TASK_ACTIONS as i, TOOL_NAME as l, TaskParams as m, MSG_NO_TASKS as n, TASK_CONTEXTS as o, TaskItemSchema as p, MSG_UPSERT_FIELD_MISPLACED as r, TASK_STATUSES as s, ERR_REQUIRES_INTERACTIVE as t, TaskAssignmentParams as u };
+//# sourceMappingURL=task-DHSvdK6E.d.mts.map

package/dist/task-DHSvdK6E.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-DHSvdK6E.d.mts","names":[],"sources":["../src/schemas/task.ts"],"mappings":";;;cAOa;cACA;cACA;cAEA;cACA;cAEA;cACA;;;;;;;;;cAUA;;;;;;;;;iBAUG,uBAAuB,QAAQ,YAAY;;cAK9C;;;;;;cAcA,gBAAc,KAAA;;;;;;;;;;;;;;cA2Dd,sBAAoB,KAAA;;;;;;;;;;;;;;;;cA6BpB,kBAAgB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCjB,iBAAiB,cAAc;KAC/B,uBAAuB,cAAc;KACrC,aAAa,cAAc"}