@agimon-ai/doompi-task 0.0.1-alpha.4 → 0.0.1-alpha.40

package/dist/services/store/taskGraph.cjs

@@ -0,0 +1,2 @@
+const e=`completed`,t=`deleted`;function n(n){let r=n.filter(e=>e.status!==t);return r.length>0&&r.every(t=>t.status===e)}function r(e,t,n){let r=new Map;for(let i of e)i.id===t?r.set(i.id,[...new Set([...i.blockedBy??[],...n])]):r.set(i.id,i.blockedBy?[...i.blockedBy]:[]);let i=new Set,a=new Set,o=e=>{if(i.has(e))return!0;if(a.has(e))return!1;i.add(e);for(let t of r.get(e)??[])if(o(t))return!0;return i.delete(e),a.add(e),!1};for(let e of r.keys())if(o(e))return!0;return!1}function i(e){let t=new Map;for(let n of e)for(let e of n.blockedBy??[]){let r=t.get(e)??[];r.push(n.id),t.set(e,r)}return t}function a(n,r){return(r.blockedBy??[]).filter(r=>{let i=n.find(e=>e.id===r);return i?i.status!==e&&i.status!==t:!1})}function o(e,t){return a(e,t).length>0}exports.deriveBlocks=i,exports.detectCycle=r,exports.isBlocked=o,exports.isTaskListComplete=n,exports.unresolvedBlockers=a;
+//# sourceMappingURL=taskGraph.cjs.map

package/dist/services/store/taskGraph.cjs.map

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

package/dist/services/store/taskGraph.d.cts

@@ -0,0 +1,25 @@
+import { Task } from "./types.cjs";
+//#region src/services/store/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 { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };
+//# sourceMappingURL=taskGraph.d.cts.map

package/dist/services/store/taskGraph.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph.d.cts","names":[],"sources":["../../../src/services/store/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"}

package/dist/services/store/taskGraph.d.mts

@@ -0,0 +1,25 @@
+import { Task } from "./types.mjs";
+//#region src/services/store/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 { deriveBlocks, detectCycle, isBlocked, isTaskListComplete, unresolvedBlockers };
+//# sourceMappingURL=taskGraph.d.mts.map

package/dist/services/store/taskGraph.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskGraph.d.mts","names":[],"sources":["../../../src/services/store/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"}

package/dist/services/store/taskGraph.mjs

@@ -0,0 +1,2 @@
+const e=`completed`,t=`deleted`;function n(n){let r=n.filter(e=>e.status!==t);return r.length>0&&r.every(t=>t.status===e)}function r(e,t,n){let r=new Map;for(let i of e)i.id===t?r.set(i.id,[...new Set([...i.blockedBy??[],...n])]):r.set(i.id,i.blockedBy?[...i.blockedBy]:[]);let i=new Set,a=new Set,o=e=>{if(i.has(e))return!0;if(a.has(e))return!1;i.add(e);for(let t of r.get(e)??[])if(o(t))return!0;return i.delete(e),a.add(e),!1};for(let e of r.keys())if(o(e))return!0;return!1}function i(e){let t=new Map;for(let n of e)for(let e of n.blockedBy??[]){let r=t.get(e)??[];r.push(n.id),t.set(e,r)}return t}function a(n,r){return(r.blockedBy??[]).filter(r=>{let i=n.find(e=>e.id===r);return i?i.status!==e&&i.status!==t:!1})}function o(e,t){return a(e,t).length>0}export{i as deriveBlocks,r as detectCycle,o as isBlocked,n as isTaskListComplete,a as unresolvedBlockers};
+//# sourceMappingURL=taskGraph.mjs.map

package/dist/services/store/taskGraph.mjs.map

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

package/dist/services/store/types.cjs

@@ -0,0 +1,2 @@
+function e(){return{version:1,rev:0,nextId:1,tasks:[]}}function t(e){let t=e.delegation?.state;return t===`requested`||t===`running`}exports.DELETED_STATUS=`deleted`,exports.STORE_SCHEMA_VERSION=1,exports.emptyDocument=e,exports.isDelegationActive=t;
+//# sourceMappingURL=types.cjs.map

package/dist/services/store/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","names":[],"sources":["../../../src/services/store/types.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-extension-contracts/subagent-tool';\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/** A delegation is \"live\" while the owning run may still produce a response. */\nexport function isDelegationActive(task: Task): boolean {\n  const state = task.delegation?.state;\n  return state === 'requested' || state === 'running';\n}\n"],"mappings":"AAyEA,SAAgB,GAA8B,CAC5C,MAAO,CAAE,QAAA,EAA+B,IAAK,EAAG,OAAQ,EAAG,MAAO,CAAC,CAAE,CACvE,CAiHA,SAAgB,EAAmB,EAAqB,CACtD,IAAM,EAAQ,EAAK,YAAY,MAC/B,OAAO,IAAU,aAAe,IAAU,SAC5C"}

package/dist/services/store/types.d.cts

@@ -0,0 +1,177 @@
+import { InlineAgent } from "@agimon-ai/doompi-extension-contracts/subagent-tool";
+//#region src/services/store/types.d.ts
+type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+declare const DELETED_STATUS: TaskStatus;
+type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
+type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** Terminal result of a delegated subagent run, copied off the delegation response. */
+interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+/**
+ * Delegation bookkeeping attached to a task that was handed to a subagent.
+ *
+ * `pid` is the harness process that owns the run: it is the only way to tell an
+ * genuinely-running delegation from one orphaned by a harness crash, since the
+ * child dies with its parent but the file survives.
+ */
+interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+declare const STORE_SCHEMA_VERSION = 1;
+/** The complete on-disk document. `rev` increments on every committed write. */
+interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+declare function emptyDocument(): TaskDocument;
+/**
+ * A dependency target inside an upsert item: an existing task id, or the `ref`
+ * of a task created earlier in the same call.
+ *
+ * Refs must start with a letter (see `REF_PATTERN`), so a ref is structurally
+ * unconfusable with a stringified id and the discrimination is just `typeof`.
+ */
+type DepToken = number | string;
+/**
+ * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
+ *
+ * `blockedBy` (absolute set) is create-only and `addBlockedBy`/`removeBlockedBy`
+ * (additive merge) are update-only, matching the split the two former actions
+ * had. A field used against the wrong kind fails that item rather than being
+ * silently ignored.
+ */
+interface TaskItemMutation {
+  id?: number;
+  ref?: string;
+  subject?: string;
+  description?: string;
+  activeForm?: string;
+  status?: TaskStatus;
+  blockedBy?: DepToken[];
+  addBlockedBy?: DepToken[];
+  removeBlockedBy?: DepToken[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * What one upsert item did. `index` is its position in the request array, so a
+ * model reading a partial result can tell which entries still need resending.
+ *
+ * `message` is unprefixed: the `item[N] failed:` framing belongs to the
+ * formatter, because the Task Space overlay shows this text on its own.
+ */
+type UpsertItemOutcome = {
+  index: number;
+  kind: 'created';
+  id: number;
+  subject: string;
+  status: TaskStatus;
+  ref?: string;
+  blockedBy?: number[];
+} | {
+  index: number;
+  kind: 'updated';
+  id: number;
+  fromStatus: TaskStatus;
+  toStatus: TaskStatus;
+} | {
+  index: number;
+  kind: 'unchanged';
+  id: number;
+  status: TaskStatus;
+} | {
+  index: number;
+  kind: 'failed';
+  message: string;
+  id?: number;
+  ref?: string;
+};
+/** Which tasks an upsert touched, so renderResult names them instead of guessing. */
+interface UpsertSummary {
+  /** Ids of applied entries, in request order. A failed entry contributes nothing. */
+  applied: number[];
+  failed: number;
+}
+/** One task-to-agent handoff inside a native assignment batch. */
+interface TaskAssignment {
+  id: number;
+  agent: string;
+  inlineAgent?: InlineAgent;
+  instructions?: string;
+  relevantFiles?: string[];
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+/** Which assignment entries started, so renderResult can show one consolidated batch. */
+interface AssignmentSummary {
+  /** Ids of successful entries, in request order. A failed entry contributes nothing. */
+  assigned: number[];
+  failed: number;
+}
+/**
+ * Open-shape input bag the reducer accepts. The index signature lets the
+ * runtime pass a TypeBox `Static<typeof TaskParamsSchema>` through without
+ * casting each field.
+ *
+ * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
+ * `status` would be ambiguous once one call can carry many tasks.
+ */
+interface TaskMutationParams {
+  [key: string]: unknown;
+  tasks?: TaskItemMutation[];
+  /** `assign` only: independent task-to-agent handoffs dispatched by one tool call. */
+  assignments?: TaskAssignment[];
+  /** `list` filter only. To set a status, upsert the task by id. */
+  status?: TaskStatus;
+  /** `get`, `delete`, and `cancel` only. Assign ids live in `assignments[]`. */
+  id?: number;
+  includeDeleted?: boolean;
+}
+/** Snapshot returned under a tool result's `details` for renderResult. */
+interface TaskDetails {
+  action: TaskAction;
+  params: Record<string, unknown>;
+  tasks: Task[];
+  nextId: number;
+  rev: number;
+  error?: string;
+  upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
+}
+/** A delegation is "live" while the owning run may still produce a response. */
+declare function isDelegationActive(task: Task): boolean;
+//#endregion
+export { AssignmentSummary, DELETED_STATUS, DelegationResult, DelegationState, DepToken, STORE_SCHEMA_VERSION, Task, TaskAction, TaskAssignment, TaskDelegation, TaskDetails, TaskDocument, TaskItemMutation, TaskMutationParams, TaskStatus, UpsertItemOutcome, UpsertSummary, emptyDocument, isDelegationActive };
+//# sourceMappingURL=types.d.cts.map

package/dist/services/store/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/services/store/types.ts"],"mappings":";;KAUY;cAEC,gBAAgB;KAEjB;KAEA;;UAGK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;UAUe;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,WAAW;EACX;EACA;EACA,aAAa;;cAGF;;UAGI;EACf;EACA;EACA;EACA,OAAO;;iBAGO,iBAAiB;;;;;;;;KAWrB;;;;;;;;;UAUK;EACf;EACA;EACA;EACA;EACA;EACA,SAAS;EACT,YAAY;EACZ,eAAe;EACf,kBAAkB;EAClB;EACA,WAAW;;;;;;;;;KAUD;EAEN;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;EAEA;EAAe;EAAiB;EAAY,YAAY;EAAY,UAAU;;EAC9E;EAAe;EAAmB;EAAY,QAAQ;;EACtD;EAAe;EAAgB;EAAiB;EAAa;;;UAGlD;;EAEf;EACA;;;UAIe;EACf;EACA;EACA,cAAc;EACd;EACA;EACA;EACA;EACA;;;UAIe;;EAEf;EACA;;;;;;;;;;UAWe;GACd;EACD,QAAQ;;EAER,cAAc;;EAEd,SAAS;;EAET;EACA;;;UAIe;EACf,QAAQ;EACR,QAAQ;EACR,OAAO;EACP;EACA;EACA;EACA,SAAS;EACT,aAAa;;;iBAIC,mBAAmB,MAAM"}

package/dist/services/store/types.d.mts

@@ -0,0 +1,177 @@
+import { InlineAgent } from "@agimon-ai/doompi-extension-contracts/subagent-tool";
+//#region src/services/store/types.d.ts
+type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+declare const DELETED_STATUS: TaskStatus;
+type TaskAction = 'upsert' | 'list' | 'get' | 'delete' | 'clear' | 'assign' | 'cancel';
+type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** Terminal result of a delegated subagent run, copied off the delegation response. */
+interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+/**
+ * Delegation bookkeeping attached to a task that was handed to a subagent.
+ *
+ * `pid` is the harness process that owns the run: it is the only way to tell an
+ * genuinely-running delegation from one orphaned by a harness crash, since the
+ * child dies with its parent but the file survives.
+ */
+interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+declare const STORE_SCHEMA_VERSION = 1;
+/** The complete on-disk document. `rev` increments on every committed write. */
+interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+declare function emptyDocument(): TaskDocument;
+/**
+ * A dependency target inside an upsert item: an existing task id, or the `ref`
+ * of a task created earlier in the same call.
+ *
+ * Refs must start with a letter (see `REF_PATTERN`), so a ref is structurally
+ * unconfusable with a stringified id and the discrimination is just `typeof`.
+ */
+type DepToken = number | string;
+/**
+ * One entry of an `upsert` call. No `id` creates a task; an `id` updates one.
+ *
+ * `blockedBy` (absolute set) is create-only and `addBlockedBy`/`removeBlockedBy`
+ * (additive merge) are update-only, matching the split the two former actions
+ * had. A field used against the wrong kind fails that item rather than being
+ * silently ignored.
+ */
+interface TaskItemMutation {
+  id?: number;
+  ref?: string;
+  subject?: string;
+  description?: string;
+  activeForm?: string;
+  status?: TaskStatus;
+  blockedBy?: DepToken[];
+  addBlockedBy?: DepToken[];
+  removeBlockedBy?: DepToken[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * What one upsert item did. `index` is its position in the request array, so a
+ * model reading a partial result can tell which entries still need resending.
+ *
+ * `message` is unprefixed: the `item[N] failed:` framing belongs to the
+ * formatter, because the Task Space overlay shows this text on its own.
+ */
+type UpsertItemOutcome = {
+  index: number;
+  kind: 'created';
+  id: number;
+  subject: string;
+  status: TaskStatus;
+  ref?: string;
+  blockedBy?: number[];
+} | {
+  index: number;
+  kind: 'updated';
+  id: number;
+  fromStatus: TaskStatus;
+  toStatus: TaskStatus;
+} | {
+  index: number;
+  kind: 'unchanged';
+  id: number;
+  status: TaskStatus;
+} | {
+  index: number;
+  kind: 'failed';
+  message: string;
+  id?: number;
+  ref?: string;
+};
+/** Which tasks an upsert touched, so renderResult names them instead of guessing. */
+interface UpsertSummary {
+  /** Ids of applied entries, in request order. A failed entry contributes nothing. */
+  applied: number[];
+  failed: number;
+}
+/** One task-to-agent handoff inside a native assignment batch. */
+interface TaskAssignment {
+  id: number;
+  agent: string;
+  inlineAgent?: InlineAgent;
+  instructions?: string;
+  relevantFiles?: string[];
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+/** Which assignment entries started, so renderResult can show one consolidated batch. */
+interface AssignmentSummary {
+  /** Ids of successful entries, in request order. A failed entry contributes nothing. */
+  assigned: number[];
+  failed: number;
+}
+/**
+ * Open-shape input bag the reducer accepts. The index signature lets the
+ * runtime pass a TypeBox `Static<typeof TaskParamsSchema>` through without
+ * casting each field.
+ *
+ * Per-task fields live on `tasks[]`, not here: a top-level `subject` or
+ * `status` would be ambiguous once one call can carry many tasks.
+ */
+interface TaskMutationParams {
+  [key: string]: unknown;
+  tasks?: TaskItemMutation[];
+  /** `assign` only: independent task-to-agent handoffs dispatched by one tool call. */
+  assignments?: TaskAssignment[];
+  /** `list` filter only. To set a status, upsert the task by id. */
+  status?: TaskStatus;
+  /** `get`, `delete`, and `cancel` only. Assign ids live in `assignments[]`. */
+  id?: number;
+  includeDeleted?: boolean;
+}
+/** Snapshot returned under a tool result's `details` for renderResult. */
+interface TaskDetails {
+  action: TaskAction;
+  params: Record<string, unknown>;
+  tasks: Task[];
+  nextId: number;
+  rev: number;
+  error?: string;
+  upsert?: UpsertSummary;
+  assignment?: AssignmentSummary;
+}
+/** A delegation is "live" while the owning run may still produce a response. */
+declare function isDelegationActive(task: Task): boolean;
+//#endregion
+export { AssignmentSummary, DELETED_STATUS, DelegationResult, DelegationState, DepToken, STORE_SCHEMA_VERSION, Task, TaskAction, TaskAssignment, TaskDelegation, TaskDetails, TaskDocument, TaskItemMutation, TaskMutationParams, TaskStatus, UpsertItemOutcome, UpsertSummary, emptyDocument, isDelegationActive };
+//# sourceMappingURL=types.d.mts.map

package/dist/services/store/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/services/store/types.ts"],"mappings":";;KAUY;cAEC,gBAAgB;KAEjB;KAEA;;UAGK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;UAUe;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA,WAAW;EACX;EACA;EACA,aAAa;;cAGF;;UAGI;EACf;EACA;EACA;EACA,OAAO;;iBAGO,iBAAiB;;;;;;;;KAWrB;;;;;;;;;UAUK;EACf;EACA;EACA;EACA;EACA;EACA,SAAS;EACT,YAAY;EACZ,eAAe;EACf,kBAAkB;EAClB;EACA,WAAW;;;;;;;;;KAUD;EAEN;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;EAEA;EAAe;EAAiB;EAAY,YAAY;EAAY,UAAU;;EAC9E;EAAe;EAAmB;EAAY,QAAQ;;EACtD;EAAe;EAAgB;EAAiB;EAAa;;;UAGlD;;EAEf;EACA;;;UAIe;EACf;EACA;EACA,cAAc;EACd;EACA;EACA;EACA;EACA;;;UAIe;;EAEf;EACA;;;;;;;;;;UAWe;GACd;EACD,QAAQ;;EAER,cAAc;;EAEd,SAAS;;EAET;EACA;;;UAIe;EACf,QAAQ;EACR,QAAQ;EACR,OAAO;EACP;EACA;EACA;EACA,SAAS;EACT,aAAa;;;iBAIC,mBAAmB,MAAM"}

package/dist/services/store/types.mjs

@@ -0,0 +1,2 @@
+const e=`deleted`,t=1;function n(){return{version:1,rev:0,nextId:1,tasks:[]}}function r(e){let t=e.delegation?.state;return t===`requested`||t===`running`}export{e as DELETED_STATUS,t as STORE_SCHEMA_VERSION,n as emptyDocument,r as isDelegationActive};
+//# sourceMappingURL=types.mjs.map

package/dist/services/store/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../../src/services/store/types.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-extension-contracts/subagent-tool';\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/** A delegation is \"live\" while the owning run may still produce a response. */\nexport function isDelegationActive(task: Task): boolean {\n  const state = task.delegation?.state;\n  return state === 'requested' || state === 'running';\n}\n"],"mappings":"AAYA,MAAa,EAA6B,UAmD7B,EAAuB,EAUpC,SAAgB,GAA8B,CAC5C,MAAO,CAAE,QAAA,EAA+B,IAAK,EAAG,OAAQ,EAAG,MAAO,CAAC,CAAE,CACvE,CAiHA,SAAgB,EAAmB,EAAqB,CACtD,IAAM,EAAQ,EAAK,YAAY,MAC/B,OAAO,IAAU,aAAe,IAAU,SAC5C"}

package/dist/store/invariants.cjs

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e={pending:new Set([`in_progress`,`completed`,`failed`,`deleted`]),in_progress:new Set([`pending`,`completed`,`failed`,`deleted`]),failed:new Set([`pending`,`in_progress`,`completed`,`deleted`]),completed:new Set([`deleted`]),deleted:new Set};function t(t,n){return t===n||e[t].has(n)}exports.VALID_TRANSITIONS=e,exports.isTransitionValid=t;
-//# sourceMappingURL=invariants.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../services/store/invariants.cjs");exports.VALID_TRANSITIONS=e.VALID_TRANSITIONS,exports.canonicalizeTasks=e.canonicalizeTasks,exports.isTransitionValid=e.isTransitionValid;

package/dist/store/invariants.d.cts

@@ -1,14 +1,2 @@
-import { TaskStatus } from "./types.cjs";
-//#region src/store/invariants.d.ts
-/**
- * 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.
- */
-declare const VALID_TRANSITIONS: Record<TaskStatus, ReadonlySet<TaskStatus>>;
-declare function isTransitionValid(from: TaskStatus, to: TaskStatus): boolean;
-//#endregion
-export { VALID_TRANSITIONS, isTransitionValid };
-//# sourceMappingURL=invariants.d.cts.map
+import { VALID_TRANSITIONS, canonicalizeTasks, isTransitionValid } from "../services/store/invariants.cjs";
+export { VALID_TRANSITIONS, canonicalizeTasks, isTransitionValid };

package/dist/store/invariants.d.mts

@@ -1,14 +1,2 @@
-import { TaskStatus } from "./types.mjs";
-//#region src/store/invariants.d.ts
-/**
- * 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.
- */
-declare const VALID_TRANSITIONS: Record<TaskStatus, ReadonlySet<TaskStatus>>;
-declare function isTransitionValid(from: TaskStatus, to: TaskStatus): boolean;
-//#endregion
-export { VALID_TRANSITIONS, isTransitionValid };
-//# sourceMappingURL=invariants.d.mts.map
+import { VALID_TRANSITIONS, canonicalizeTasks, isTransitionValid } from "../services/store/invariants.mjs";
+export { VALID_TRANSITIONS, canonicalizeTasks, isTransitionValid };

package/dist/store/invariants.mjs

@@ -1,2 +1 @@
-const e={pending:new Set([`in_progress`,`completed`,`failed`,`deleted`]),in_progress:new Set([`pending`,`completed`,`failed`,`deleted`]),failed:new Set([`pending`,`in_progress`,`completed`,`deleted`]),completed:new Set([`deleted`]),deleted:new Set};function t(t,n){return t===n||e[t].has(n)}export{e as VALID_TRANSITIONS,t as isTransitionValid};
-//# sourceMappingURL=invariants.mjs.map
+import{VALID_TRANSITIONS as e,canonicalizeTasks as t,isTransitionValid as n}from"../services/store/invariants.mjs";export{e as VALID_TRANSITIONS,t as canonicalizeTasks,n as isTransitionValid};

package/dist/store/paths.cjs

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../_virtual/_rolldown/runtime.cjs");let t=require("node:path");t=e.__toESM(t,1);let n=require("node:os");n=e.__toESM(n,1);let r=require("node:child_process"),i=require("node:fs");i=e.__toESM(i,1);let a=require("@agimon-ai/doompi-extension-contracts/child-process");const o=`DOOM_TASK_STORE`,s=`doom-task`,c=`tasks.json`,l=`utf8`;function u(e,t){try{let n=(0,r.execFileSync)(`git`,e,{cwd:t,encoding:l,stdio:[`ignore`,`pipe`,`ignore`]}).trim();return n.length>0?n:void 0}catch{return}}function d(e){let r=e.PI_CODING_AGENT_DIR?.trim();return r===`~`?n.default.homedir():r?.startsWith(`~/`)?t.default.join(n.default.homedir(),r.slice(2)):r?t.default.resolve(r):t.default.join(n.default.homedir(),`.pi`,`agent`)}function f(e,n){let r=t.default.relative(t.default.resolve(e),t.default.resolve(n));return r===``||!r.startsWith(`..`)&&!t.default.isAbsolute(r)}function p(e,t=process.env){if(!t[a.SUBAGENT_CHILD_ENV])return e;let n=t[a.SUBAGENT_PARENT_SESSION_ENV]?.trim();if(!n)throw Error(`${a.SUBAGENT_PARENT_SESSION_ENV} is required in a subagent child`);return n}function m(e=process.cwd(),n=process.env,r=`standalone`){let i=n[o]?.trim();if(i)return t.default.resolve(i);let a=r.trim();if(!a)throw Error(`doom-task session id cannot be blank`);return t.default.join(d(n),s,a,c)}function h(e=process.env){return!!e[o]?.trim()}function g(e=process.cwd()){let n=u([`rev-parse`,`--path-format=absolute`,`--git-common-dir`],e);return n?t.default.join(n,s):void 0}function _(e,n=process.cwd()){let r={removed:[],errors:[]},a=g(n);if(!a||t.default.basename(a)!==s||f(a,e))return r;try{if(!i.default.existsSync(a))return r;i.default.rmSync(a,{recursive:!0,force:!0}),r.removed.push(a)}catch(e){r.errors.push(`Could not remove legacy task store ${a}: ${String(e)}`)}return r}function v(e,n,r=Date.now()){let a={removed:[],errors:[]},o=t.default.dirname(e),s=t.default.dirname(o),u;try{u=i.default.readdirSync(s)}catch(e){return e.code===`ENOENT`||a.errors.push(`Could not read task store directory ${s}: ${String(e)}`),a}for(let e of u){let u=t.default.join(s,e),d=t.default.join(u,c);if(!(u===o||!i.default.existsSync(d)))try{if(i.default.existsSync(y(d))||(JSON.parse(i.default.readFileSync(d,l)),r-i.default.statSync(d).mtimeMs<=n))continue;i.default.rmSync(u,{recursive:!0,force:!0}),a.removed.push(u)}catch(e){a.errors.push(`Could not sweep task store ${d}: ${String(e)}`)}}return a}function y(e){return`${e}.lock`}function b(e,t=process.pid){return`${e}.tmp.${t}`}exports.STORE_PATH_ENV=o,exports.hasStorePathOverride=h,exports.lockPathFor=y,exports.removeLegacyStoreDirectory=_,exports.resolveLegacyStoreDirectory=g,exports.resolveSessionKey=p,exports.resolveStorePath=m,exports.sweepStoreFiles=v,exports.tempPathFor=b;
-//# sourceMappingURL=paths.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../adapters/store/paths.cjs");exports.STORE_PATH_ENV=e.STORE_PATH_ENV,exports.hasStorePathOverride=e.hasStorePathOverride,exports.lockPathFor=e.lockPathFor,exports.removeLegacyStoreDirectory=e.removeLegacyStoreDirectory,exports.removeLegacyStoreDirectoryAsync=e.removeLegacyStoreDirectoryAsync,exports.resolveLegacyStoreDirectory=e.resolveLegacyStoreDirectory,exports.resolveLegacyStoreDirectoryAsync=e.resolveLegacyStoreDirectoryAsync,exports.resolveSessionKey=e.resolveSessionKey,exports.resolveStorePath=e.resolveStorePath,exports.sweepStoreFiles=e.sweepStoreFiles,exports.sweepStoreFilesAsync=e.sweepStoreFilesAsync,exports.tempPathFor=e.tempPathFor;

package/dist/store/paths.d.cts

@@ -1,23 +1,2 @@
-//#region src/store/paths.d.ts
-declare const STORE_PATH_ENV = "DOOM_TASK_STORE";
-/** Resolve the tree root without relying on extension startup order. */
-declare function resolveSessionKey(rootSessionId: string, env?: NodeJS.ProcessEnv): string;
-/** Resolve one root session tree to a task document under the Pi agent directory. */
-declare function resolveStorePath(_cwd?: string, env?: NodeJS.ProcessEnv, sessionKey?: string): string;
-/** Whether a deliberate unscoped task-store override is active. */
-declare function hasStorePathOverride(env?: NodeJS.ProcessEnv): boolean;
-/** Exact legacy Git-directory store, if the current working tree has one. */
-declare function resolveLegacyStoreDirectory(cwd?: string): string | undefined;
-interface StoreSweepResult {
-  removed: string[];
-  errors: string[];
-}
-/** Remove only the validated legacy Git store unless it contains the active override. */
-declare function removeLegacyStoreDirectory(currentStorePath: string, cwd?: string): StoreSweepResult;
-/** Delete expired sibling session stores while preserving active or unreadable stores. */
-declare function sweepStoreFiles(currentStorePath: string, ttlMs: number, now?: number): StoreSweepResult;
-declare function lockPathFor(storePath: string): string;
-declare function tempPathFor(storePath: string, pid?: number): string;
-//#endregion
-export { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, resolveLegacyStoreDirectory, resolveSessionKey, resolveStorePath, sweepStoreFiles, tempPathFor };
-//# sourceMappingURL=paths.d.cts.map
+import { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor } from "../adapters/store/paths.cjs";
+export { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor };

package/dist/store/paths.d.mts

@@ -1,23 +1,2 @@
-//#region src/store/paths.d.ts
-declare const STORE_PATH_ENV = "DOOM_TASK_STORE";
-/** Resolve the tree root without relying on extension startup order. */
-declare function resolveSessionKey(rootSessionId: string, env?: NodeJS.ProcessEnv): string;
-/** Resolve one root session tree to a task document under the Pi agent directory. */
-declare function resolveStorePath(_cwd?: string, env?: NodeJS.ProcessEnv, sessionKey?: string): string;
-/** Whether a deliberate unscoped task-store override is active. */
-declare function hasStorePathOverride(env?: NodeJS.ProcessEnv): boolean;
-/** Exact legacy Git-directory store, if the current working tree has one. */
-declare function resolveLegacyStoreDirectory(cwd?: string): string | undefined;
-interface StoreSweepResult {
-  removed: string[];
-  errors: string[];
-}
-/** Remove only the validated legacy Git store unless it contains the active override. */
-declare function removeLegacyStoreDirectory(currentStorePath: string, cwd?: string): StoreSweepResult;
-/** Delete expired sibling session stores while preserving active or unreadable stores. */
-declare function sweepStoreFiles(currentStorePath: string, ttlMs: number, now?: number): StoreSweepResult;
-declare function lockPathFor(storePath: string): string;
-declare function tempPathFor(storePath: string, pid?: number): string;
-//#endregion
-export { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, resolveLegacyStoreDirectory, resolveSessionKey, resolveStorePath, sweepStoreFiles, tempPathFor };
-//# sourceMappingURL=paths.d.mts.map
+import { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor } from "../adapters/store/paths.mjs";
+export { STORE_PATH_ENV, StoreSweepResult, hasStorePathOverride, lockPathFor, removeLegacyStoreDirectory, removeLegacyStoreDirectoryAsync, resolveLegacyStoreDirectory, resolveLegacyStoreDirectoryAsync, resolveSessionKey, resolveStorePath, sweepStoreFiles, sweepStoreFilesAsync, tempPathFor };

package/dist/store/paths.mjs

@@ -1,2 +1 @@
-import e from"node:path";import t from"node:os";import{execFileSync as n}from"node:child_process";import r from"node:fs";import{SUBAGENT_CHILD_ENV as i,SUBAGENT_PARENT_SESSION_ENV as a}from"@agimon-ai/doompi-extension-contracts/child-process";const o=`DOOM_TASK_STORE`,s=`doom-task`,c=`tasks.json`,l=`utf8`;function u(e,t){try{let r=n(`git`,e,{cwd:t,encoding:l,stdio:[`ignore`,`pipe`,`ignore`]}).trim();return r.length>0?r:void 0}catch{return}}function d(n){let r=n.PI_CODING_AGENT_DIR?.trim();return r===`~`?t.homedir():r?.startsWith(`~/`)?e.join(t.homedir(),r.slice(2)):r?e.resolve(r):e.join(t.homedir(),`.pi`,`agent`)}function f(t,n){let r=e.relative(e.resolve(t),e.resolve(n));return r===``||!r.startsWith(`..`)&&!e.isAbsolute(r)}function p(e,t=process.env){if(!t[i])return e;let n=t[a]?.trim();if(!n)throw Error(`${a} is required in a subagent child`);return n}function m(t=process.cwd(),n=process.env,r=`standalone`){let i=n[o]?.trim();if(i)return e.resolve(i);let a=r.trim();if(!a)throw Error(`doom-task session id cannot be blank`);return e.join(d(n),s,a,c)}function h(e=process.env){return!!e[o]?.trim()}function g(t=process.cwd()){let n=u([`rev-parse`,`--path-format=absolute`,`--git-common-dir`],t);return n?e.join(n,s):void 0}function _(t,n=process.cwd()){let i={removed:[],errors:[]},a=g(n);if(!a||e.basename(a)!==s||f(a,t))return i;try{if(!r.existsSync(a))return i;r.rmSync(a,{recursive:!0,force:!0}),i.removed.push(a)}catch(e){i.errors.push(`Could not remove legacy task store ${a}: ${String(e)}`)}return i}function v(t,n,i=Date.now()){let a={removed:[],errors:[]},o=e.dirname(t),s=e.dirname(o),u;try{u=r.readdirSync(s)}catch(e){return e.code===`ENOENT`||a.errors.push(`Could not read task store directory ${s}: ${String(e)}`),a}for(let t of u){let u=e.join(s,t),d=e.join(u,c);if(!(u===o||!r.existsSync(d)))try{if(r.existsSync(y(d))||(JSON.parse(r.readFileSync(d,l)),i-r.statSync(d).mtimeMs<=n))continue;r.rmSync(u,{recursive:!0,force:!0}),a.removed.push(u)}catch(e){a.errors.push(`Could not sweep task store ${d}: ${String(e)}`)}}return a}function y(e){return`${e}.lock`}function b(e,t=process.pid){return`${e}.tmp.${t}`}export{o as STORE_PATH_ENV,h as hasStorePathOverride,y as lockPathFor,_ as removeLegacyStoreDirectory,g as resolveLegacyStoreDirectory,p as resolveSessionKey,m as resolveStorePath,v as sweepStoreFiles,b as tempPathFor};
-//# sourceMappingURL=paths.mjs.map
+import{STORE_PATH_ENV as e,hasStorePathOverride as t,lockPathFor as n,removeLegacyStoreDirectory as r,removeLegacyStoreDirectoryAsync as i,resolveLegacyStoreDirectory as a,resolveLegacyStoreDirectoryAsync as o,resolveSessionKey as s,resolveStorePath as c,sweepStoreFiles as l,sweepStoreFilesAsync as u,tempPathFor as d}from"../adapters/store/paths.mjs";export{e as STORE_PATH_ENV,t as hasStorePathOverride,n as lockPathFor,r as removeLegacyStoreDirectory,i as removeLegacyStoreDirectoryAsync,a as resolveLegacyStoreDirectory,o as resolveLegacyStoreDirectoryAsync,s as resolveSessionKey,c as resolveStorePath,l as sweepStoreFiles,u as sweepStoreFilesAsync,d as tempPathFor};

package/dist/store/processLiveness.cjs

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){try{return process.kill(e,0),!0}catch(e){return e.code===`EPERM`}}exports.isProcessAlive=e;
-//# sourceMappingURL=processLiveness.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../services/store/processLiveness.cjs");exports.isProcessAlive=e.isProcessAlive;