@ai-setting/roy-agent-core 1.7.51 → 1.7.53

package/dist/env/task/backend/index.js

@@ -0,0 +1,704 @@
+import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+// src/env/task/backend/task-store-backend.ts
+var DELIVERABLE_OPERATION_PREFIX = "Deliverable: ";
+function formatDeliverableForOperation(deliverableStoragePath) {
+  if (!deliverableStoragePath)
+    return;
+  return `${DELIVERABLE_OPERATION_PREFIX}${deliverableStoragePath}`;
+}
+var SCAN_ALL = 1e6;
+
+class TaskStoreBackend {
+  port;
+  options;
+  constructor(port, options = {}) {
+    this.port = port;
+    this.options = options;
+  }
+  get defaultSessionId() {
+    return this.options.sessionId ?? "unknown";
+  }
+  async resolve(id) {
+    const asNum = toNumericHandle(id);
+    if (asNum !== undefined) {
+      if (typeof this.port.getTaskByNum === "function") {
+        return await this.port.getTaskByNum(asNum);
+      }
+      return (await this.scanAllTasks()).find((t) => t.id === asNum) ?? null;
+    }
+    return await this.port.getTask(String(id));
+  }
+  toTask(record) {
+    const { nativeId: _nativeId, ...task } = record;
+    return task;
+  }
+  toOperation(record) {
+    const { nativeId: _nativeId, ...operation } = record;
+    return operation;
+  }
+  async scanAllTasks() {
+    const res = await this.port.listTasks({
+      limit: SCAN_ALL,
+      offset: 0,
+      includeArchived: true
+    });
+    return res.tasks;
+  }
+  async createTask(input) {
+    const sessionId = input.sessionId ?? this.defaultSessionId;
+    let parentNum;
+    if (input.parent_task_id !== undefined && input.parent_task_id !== null) {
+      const parent = await this.resolve(input.parent_task_id);
+      if (!parent) {
+        throw new Error(`Parent task #${input.parent_task_id} not found.`);
+      }
+      parentNum = parent.id;
+    }
+    const created = await this.port.createTask({
+      title: input.title,
+      description: input.description,
+      priority: input.priority,
+      type: input.type,
+      goals_and_expected_deliverables: input.goals_and_expected_deliverables,
+      ...parentNum !== undefined ? { parent_task_id: parentNum } : {},
+      due_date: input.due_date,
+      tags: input.tags,
+      project_path: input.project_path,
+      context: input.context,
+      sessionId
+    });
+    await this.createOperation({
+      taskId: created.id,
+      sessionId,
+      milestoneType: "create",
+      milestoneTitle: `Task created: ${created.title}`,
+      milestoneDescription: created.description ?? ""
+    });
+    return this.toTask(created);
+  }
+  async getTask(id) {
+    const record = await this.resolve(id);
+    return record ? this.toTask(record) : null;
+  }
+  async getTaskWithOperations(id) {
+    const task = await this.getTask(id);
+    if (!task)
+      return null;
+    const operations = await this.listOperations({ taskId: task.id, limit: SCAN_ALL, offset: 0 });
+    return { ...task, operations };
+  }
+  async listTasks(options = {}) {
+    const limit = options.limit ?? 20;
+    const offset = options.offset ?? 0;
+    let views = (await this.scanAllTasks()).map((t) => this.toTask(t));
+    views = this.applyFilters(views, options);
+    return { tasks: views.slice(offset, offset + limit), total: views.length };
+  }
+  async updateTask(id, input) {
+    const record = await this.resolve(id);
+    if (!record)
+      return null;
+    let parentNum;
+    if (input.parent_task_id !== undefined) {
+      if (input.parent_task_id === null) {
+        parentNum = null;
+      } else {
+        const parent = await this.resolve(input.parent_task_id);
+        if (!parent)
+          throw new Error(`Parent task #${input.parent_task_id} not found.`);
+        parentNum = parent.id;
+      }
+    }
+    const updated = await this.port.updateTask(record.nativeId, {
+      title: input.title,
+      description: input.description,
+      status: input.status,
+      priority: input.priority,
+      type: input.type,
+      progress: input.progress,
+      current_status: input.current_status,
+      goals_and_expected_deliverables: input.goals_and_expected_deliverables,
+      due_date: input.due_date,
+      tags: input.tags,
+      project_path: input.project_path,
+      context: input.context,
+      ...parentNum !== undefined ? { parent_task_id: parentNum } : {}
+    });
+    return updated ? this.toTask(updated) : null;
+  }
+  async deleteTask(id) {
+    const record = await this.resolve(id);
+    if (!record)
+      return false;
+    return await this.port.deleteTask(record.nativeId);
+  }
+  async completeTask(id, sessionId, deliverable) {
+    const record = await this.resolve(id);
+    if (!record)
+      return null;
+    if (record.type === "cycle") {
+      throw new Error(`Cannot complete cycle task: #${record.id} - ${record.title}. Cycle tasks are not meant to be completed.`);
+    }
+    const patch = { status: "completed", progress: 100 };
+    if (deliverable) {
+      patch.context = mergeDeliverableIntoContext(record.context, deliverable);
+    }
+    const updated = await this.port.updateTask(record.nativeId, patch);
+    if (!updated)
+      return null;
+    const formatted = formatDeliverableForOperation(deliverable);
+    await this.createOperation({
+      taskId: updated.id,
+      sessionId: sessionId ?? this.defaultSessionId,
+      milestoneType: "completed",
+      milestoneTitle: `Completed: ${updated.title}`,
+      milestoneDescription: formatted ?? "Task completed",
+      ...deliverable ? { mdPath: deliverable } : {}
+    });
+    const reread = await this.resolve(record.nativeId);
+    return this.toTask(reread ?? updated);
+  }
+  async getTaskTree(id, depth = -1) {
+    const root = await this.resolve(id);
+    if (!root)
+      return [];
+    if (depth === 0)
+      return [];
+    const views = (await this.scanAllTasks()).map((t) => this.toTask(t));
+    const byParent = new Map;
+    for (const t of views) {
+      if (t.parent_task_id === undefined)
+        continue;
+      const bucket = byParent.get(t.parent_task_id) ?? [];
+      bucket.push(t);
+      byParent.set(t.parent_task_id, bucket);
+    }
+    const collected = [];
+    const seen = new Set([root.id]);
+    let frontier = [root.id];
+    let level = 0;
+    while (frontier.length > 0) {
+      if (depth !== -1 && level >= depth)
+        break;
+      const next = [];
+      for (const parentId of frontier) {
+        for (const child of byParent.get(parentId) ?? []) {
+          if (seen.has(child.id))
+            continue;
+          seen.add(child.id);
+          collected.push(child);
+          next.push(child.id);
+        }
+      }
+      frontier = next;
+      level++;
+    }
+    return collected;
+  }
+  async searchTasksByKeywords(keywords, options = {}) {
+    const limit = options.limit ?? 20;
+    const offset = options.offset ?? 0;
+    let candidates = (await this.scanAllTasks()).map((t) => this.toTask(t));
+    candidates = this.applyFilters(candidates, options);
+    if (options.excludeTaskId !== undefined) {
+      candidates = candidates.filter((t) => t.id !== options.excludeTaskId);
+    }
+    const needles = keywords.map((k) => k.toLowerCase()).filter((k) => k.length > 0);
+    const hits = needles.length === 0 ? candidates : candidates.filter((t) => {
+      const haystack = [
+        t.title,
+        t.description,
+        t.goals_and_expected_deliverables,
+        t.current_status,
+        (t.tags ?? []).join(" "),
+        t.project_path
+      ].join(" ").toLowerCase();
+      return needles.every((n) => haystack.includes(n));
+    });
+    return { tasks: hits.slice(offset, offset + limit), total: hits.length };
+  }
+  async createOperation(input) {
+    const task = await this.resolve(input.taskId);
+    if (!task)
+      throw new Error(`Task not found: ${input.taskId}`);
+    const milestoneType = input.milestoneType ?? input.actionType ?? "progress";
+    const milestoneTitle = input.milestoneTitle ?? input.actionTitle ?? "";
+    const milestoneDescription = input.milestoneDescription ?? input.actionDescription ?? "";
+    const created = await this.port.createOperation({
+      taskId: task.id,
+      taskNativeId: task.nativeId,
+      sessionId: input.sessionId ?? this.defaultSessionId,
+      milestoneType,
+      milestoneTitle,
+      milestoneDescription,
+      processDescription: input.processDescription ?? "",
+      ...input.mdPath ? { mdPath: input.mdPath } : {}
+    });
+    return this.toOperation(created);
+  }
+  async listOperations(options = {}) {
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const filterType = options.milestoneType ?? options.actionType;
+    if (options.taskId === undefined) {
+      return [];
+    }
+    const task = await this.resolve(options.taskId);
+    if (!task)
+      return [];
+    const res = await this.port.listOperations({
+      taskNativeId: task.nativeId,
+      limit: filterType ? SCAN_ALL : limit,
+      offset: filterType ? 0 : offset
+    });
+    let operations = res.operations.map((o) => this.toOperation(o));
+    if (filterType) {
+      operations = operations.filter((o) => o.milestoneType === filterType);
+      operations = operations.slice(offset, offset + limit);
+    }
+    return operations;
+  }
+  async getOperation(id) {
+    if (typeof this.port.getOperationByNum === "function") {
+      const op = await this.port.getOperationByNum(id);
+      return op ? this.toOperation(op) : null;
+    }
+    const tasks = await this.scanAllTasks();
+    for (const task of tasks) {
+      const res = await this.port.listOperations({ taskNativeId: task.nativeId, limit: SCAN_ALL });
+      const found = res.operations.find((o) => o.id === id);
+      if (found)
+        return this.toOperation(found);
+    }
+    return null;
+  }
+  async updateOperation(id, patch) {
+    const existing = await this.getOperation(id);
+    if (!existing)
+      return null;
+    if (typeof this.port.updateOperationByNum !== "function")
+      return existing;
+    const updated = await this.port.updateOperationByNum(id, {
+      sessionId: patch.sessionId ?? existing.sessionId,
+      milestoneType: patch.milestoneType ?? patch.actionType ?? existing.milestoneType,
+      milestoneTitle: patch.milestoneTitle ?? patch.actionTitle ?? existing.milestoneTitle,
+      milestoneDescription: patch.milestoneDescription ?? patch.actionDescription ?? existing.milestoneDescription,
+      processDescription: patch.processDescription ?? existing.processDescription,
+      ...patch.mdPath !== undefined ? { mdPath: patch.mdPath } : {}
+    });
+    return updated ? this.toOperation(updated) : null;
+  }
+  async deleteOperation(id) {
+    if (typeof this.port.deleteOperationByNum !== "function")
+      return false;
+    return await this.port.deleteOperationByNum(id);
+  }
+  applyFilters(views, options) {
+    let out = views;
+    const excludeArchived = options.include_archived !== true && options.status !== "archived";
+    if (excludeArchived)
+      out = out.filter((t) => t.status !== "archived");
+    if (options.status !== undefined)
+      out = out.filter((t) => t.status === options.status);
+    if (options.priority !== undefined)
+      out = out.filter((t) => t.priority === options.priority);
+    if (options.type !== undefined)
+      out = out.filter((t) => t.type === options.type);
+    if (options.parent_task_id !== undefined) {
+      out = out.filter((t) => t.parent_task_id === options.parent_task_id);
+    }
+    if (options.depth !== undefined && options.depth >= 0) {
+      const allowed = allowedIdsByDepth(out, options.depth);
+      out = out.filter((t) => allowed.has(t.id));
+    }
+    return out;
+  }
+}
+function toNumericHandle(id) {
+  if (typeof id === "number") {
+    return Number.isFinite(id) ? id : undefined;
+  }
+  return /^\d+$/.test(id) ? Number(id) : undefined;
+}
+function allowedIdsByDepth(views, depth) {
+  if (depth < 0)
+    return new Set(views.map((t) => t.id));
+  const ids = new Set(views.map((t) => t.id));
+  const byParent = new Map;
+  for (const t of views) {
+    const key = t.parent_task_id;
+    if (key === undefined || !ids.has(key))
+      continue;
+    const bucket = byParent.get(key) ?? [];
+    bucket.push(t);
+    byParent.set(key, bucket);
+  }
+  const allowed = new Set;
+  let frontier = views.filter((t) => t.parent_task_id === undefined || !ids.has(t.parent_task_id));
+  for (const t of frontier)
+    allowed.add(t.id);
+  for (let level = 1;level <= depth; level++) {
+    const next = [];
+    for (const parent of frontier) {
+      for (const child of byParent.get(parent.id) ?? []) {
+        if (allowed.has(child.id))
+          continue;
+        allowed.add(child.id);
+        next.push(child);
+      }
+    }
+    if (next.length === 0)
+      break;
+    frontier = next;
+  }
+  return allowed;
+}
+function mergeDeliverableIntoContext(rawContext, deliverable) {
+  let parsed = {};
+  if (typeof rawContext === "string" && rawContext.trim().length > 0) {
+    try {
+      const candidate = JSON.parse(rawContext);
+      if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+        parsed = candidate;
+      }
+    } catch {}
+  }
+  parsed.deliverable_storage_path = deliverable;
+  return JSON.stringify(parsed);
+}
+// src/env/task/backend/sqlite-task-port.ts
+function createSQLiteTaskPort(store) {
+  return {
+    hidesArchivedByDefault: true,
+    async createTask(input) {
+      const task = await store.createTask({
+        title: input.title,
+        description: input.description,
+        ...input.priority !== undefined ? { priority: input.priority } : {},
+        ...input.type !== undefined ? { type: input.type } : {},
+        ...input.parent_task_id !== undefined ? { parent_task_id: input.parent_task_id } : {},
+        ...input.goals_and_expected_deliverables !== undefined ? { goals_and_expected_deliverables: input.goals_and_expected_deliverables } : {},
+        ...input.due_date !== undefined ? { due_date: input.due_date } : {},
+        ...input.tags !== undefined ? { tags: input.tags } : {},
+        sessionId: input.sessionId ?? "unknown",
+        project_path: input.project_path,
+        context: input.context
+      });
+      return { ...task, nativeId: String(task.id) };
+    },
+    async getTask(nativeId) {
+      const num = Number(nativeId);
+      if (!Number.isFinite(num))
+        return null;
+      const task = await store.getTask(num);
+      return task ? { ...task, nativeId: String(task.id) } : null;
+    },
+    async getTaskByNum(num) {
+      const task = await store.getTask(num);
+      return task ? { ...task, nativeId: String(task.id) } : null;
+    },
+    async listTasks(options) {
+      const res = await store.listTasks({
+        limit: options?.limit ?? 20,
+        offset: options?.offset ?? 0,
+        ...options?.includeArchived ? { include_archived: true } : {}
+      });
+      return {
+        tasks: res.tasks.map((t) => ({ ...t, nativeId: String(t.id) })),
+        total: res.total
+      };
+    },
+    async updateTask(nativeId, patch) {
+      const num = Number(nativeId);
+      if (!Number.isFinite(num))
+        return null;
+      const task = await store.updateTask(num, patch);
+      return task ? { ...task, nativeId: String(task.id) } : null;
+    },
+    async deleteTask(nativeId) {
+      const num = Number(nativeId);
+      if (!Number.isFinite(num))
+        return false;
+      return await store.deleteTask(num);
+    },
+    async createOperation(input) {
+      const op = await store.createOperation({
+        taskId: input.taskId,
+        sessionId: input.sessionId,
+        milestoneType: input.milestoneType,
+        milestoneTitle: input.milestoneTitle,
+        milestoneDescription: input.milestoneDescription,
+        processDescription: input.processDescription,
+        ...input.mdPath ? { mdPath: input.mdPath } : {}
+      });
+      return { ...op, nativeId: String(op.id) };
+    },
+    async listOperations(options) {
+      const num = Number(options?.taskNativeId);
+      if (!Number.isFinite(num))
+        return { operations: [], total: 0 };
+      const all = await store.listOperations({ taskId: num, limit: 1e6, offset: 0 });
+      const offset = options?.offset ?? 0;
+      const limit = options?.limit ?? all.length;
+      return {
+        operations: all.slice(offset, offset + limit).map((o) => ({ ...o, nativeId: String(o.id) })),
+        total: all.length
+      };
+    },
+    async getOperationByNum(num) {
+      const op = await store.getOperation(num);
+      return op ? { ...op, nativeId: String(op.id) } : null;
+    },
+    async updateOperationByNum(num, patch) {
+      const op = await store.updateOperation(num, {
+        ...patch.milestoneTitle !== undefined ? { milestoneTitle: patch.milestoneTitle } : {},
+        ...patch.milestoneDescription !== undefined ? { milestoneDescription: patch.milestoneDescription } : {},
+        ...patch.processDescription !== undefined ? { processDescription: patch.processDescription } : {}
+      });
+      return op ? { ...op, nativeId: String(op.id) } : null;
+    },
+    async deleteOperationByNum(num) {
+      return await store.deleteOperation(num);
+    }
+  };
+}
+// src/env/task/backend/roy-sidecar-task-port.ts
+var DEFAULT_SCAN = 1e6;
+function toSidecarPatch(patch) {
+  const out = {};
+  if (patch.type !== undefined)
+    out.type = patch.type;
+  if (patch.progress !== undefined)
+    out.progress = patch.progress;
+  if (patch.current_status !== undefined)
+    out.current_status = patch.current_status;
+  if (patch.goals_and_expected_deliverables !== undefined) {
+    out.goals_and_expected_deliverables = patch.goals_and_expected_deliverables;
+  }
+  if (patch.project_path !== undefined)
+    out.project_path = patch.project_path;
+  if (patch.context !== undefined)
+    out.context = patch.context;
+  if (patch.due_date !== undefined)
+    out.due_date = patch.due_date;
+  return out;
+}
+function toStoredTask(record, vocabulary, parentNum) {
+  if (typeof record.num !== "number") {
+    throw new Error(`store did not expose a numeric handle for task ${record.id}`);
+  }
+  const side = record.roy ?? {};
+  return {
+    id: record.num,
+    nativeId: record.id,
+    title: record.title,
+    description: record.description ?? "",
+    status: vocabulary.toRoyStatus(record.status),
+    priority: vocabulary.toRoyPriority(record.priority),
+    type: side.type ?? "normal",
+    progress: typeof side.progress === "number" ? side.progress : record.status === "done" ? 100 : 0,
+    current_status: side.current_status ?? "",
+    goals_and_expected_deliverables: side.goals_and_expected_deliverables ?? "",
+    ...parentNum !== undefined ? { parent_task_id: parentNum } : {},
+    createdAt: record.created_at,
+    updatedAt: record.updated_at,
+    ...side.due_date ? { due_date: side.due_date } : {},
+    tags: vocabulary.toRoyTags(record.tags),
+    project_path: side.project_path ?? "unknown",
+    context: side.context ?? "{}"
+  };
+}
+function toStoredOperation(record) {
+  const data = record.data ?? {};
+  const milestoneType = String(data.milestoneType ?? data.actionType ?? "progress");
+  const milestoneTitle = String(data.milestoneTitle ?? data.actionTitle ?? "");
+  const milestoneDescription = String(data.milestoneDescription ?? data.actionDescription ?? "");
+  const taskIdRaw = data.taskId ?? record.task_id;
+  const taskId = typeof taskIdRaw === "number" ? taskIdRaw : typeof taskIdRaw === "string" && /^\d+$/.test(taskIdRaw) ? Number(taskIdRaw) : 0;
+  return {
+    id: typeof record.num === "number" ? record.num : 0,
+    nativeId: record.id,
+    taskId,
+    sessionId: String(data.sessionId ?? record.task_id ?? "unknown"),
+    milestoneType,
+    milestoneTitle,
+    milestoneDescription,
+    processDescription: String(data.processDescription ?? ""),
+    timestamp: record.created_at,
+    ...data.mdPath ? { mdPath: String(data.mdPath) } : {},
+    actionType: milestoneType,
+    actionTitle: milestoneTitle,
+    actionDescription: milestoneDescription
+  };
+}
+function createRoySidecarTaskPort(store, vocabulary, options = {}) {
+  const operationType = options.operationType ?? "roy.milestone";
+  const agent = options.agent ?? "roy";
+  const scanLimit = options.scanLimit ?? DEFAULT_SCAN;
+  async function parentNumMap() {
+    const all = await store.listTasks({ limit: scanLimit });
+    return new Map(all.tasks.filter((t) => typeof t.num === "number").map((t) => [t.id, t.num]));
+  }
+  async function resolveByNum(num) {
+    if (typeof store.getTaskByNum === "function")
+      return await store.getTaskByNum(num);
+    const all = await store.listTasks({ limit: scanLimit });
+    return all.tasks.find((t) => t.num === num) ?? null;
+  }
+  async function nativeIdOf(num) {
+    const nums = await parentNumMap();
+    const hit = [...nums.entries()].find(([, n]) => n === num);
+    if (!hit)
+      throw new Error(`parent task not found: ${num}`);
+    return hit[0];
+  }
+  return {
+    hidesArchivedByDefault: false,
+    async createTask(input) {
+      const parentId = input.parent_task_id !== undefined ? await nativeIdOf(input.parent_task_id) : null;
+      const sidecar = {
+        type: input.type ?? "normal",
+        progress: input.progress ?? 0,
+        current_status: input.current_status ?? "",
+        goals_and_expected_deliverables: input.goals_and_expected_deliverables ?? "",
+        project_path: input.project_path,
+        context: input.context,
+        ...input.due_date ? { due_date: input.due_date } : {}
+      };
+      const created = await store.createTask({
+        title: input.title,
+        description: input.description,
+        priority: vocabulary.toStorePriority(input.priority),
+        owner: agent,
+        tags: vocabulary.toStoreTags(input.tags),
+        parent_id: parentId,
+        session_id: input.sessionId ?? "unknown",
+        roy: sidecar
+      });
+      return toStoredTask(created, vocabulary, input.parent_task_id);
+    },
+    async getTask(nativeId) {
+      const task = await store.getTask(nativeId);
+      if (!task)
+        return null;
+      const nums = await parentNumMap();
+      return toStoredTask(task, vocabulary, task.parent_id ? nums.get(task.parent_id) : undefined);
+    },
+    async getTaskByNum(num) {
+      const task = await resolveByNum(num);
+      if (!task)
+        return null;
+      const nums = await parentNumMap();
+      return toStoredTask(task, vocabulary, task.parent_id ? nums.get(task.parent_id) : undefined);
+    },
+    async listTasks(request) {
+      const res = await store.listTasks({
+        limit: request?.limit ?? 20,
+        offset: request?.offset ?? 0
+      });
+      const nums = await parentNumMap();
+      return {
+        tasks: res.tasks.map((t) => toStoredTask(t, vocabulary, t.parent_id ? nums.get(t.parent_id) : undefined)),
+        total: res.total
+      };
+    },
+    async updateTask(nativeId, patch) {
+      const sidePatch = toSidecarPatch(patch);
+      const updated = await store.updateTask(nativeId, {
+        ...patch.title !== undefined ? { title: patch.title } : {},
+        ...patch.description !== undefined ? { description: patch.description } : {},
+        ...patch.status !== undefined ? { status: vocabulary.toStoreStatus(patch.status) } : {},
+        ...patch.priority !== undefined ? { priority: vocabulary.toStorePriority(patch.priority) } : {},
+        ...patch.tags !== undefined ? { tags: vocabulary.toStoreTags(patch.tags) } : {},
+        ...Object.keys(sidePatch).length > 0 ? { roy: sidePatch } : {}
+      });
+      if (!updated)
+        return null;
+      let parentNum;
+      if (patch.parent_task_id !== undefined) {
+        const newParent = patch.parent_task_id === null ? null : await nativeIdOf(patch.parent_task_id);
+        if (typeof store.setParentId === "function") {
+          await store.setParentId(nativeId, newParent);
+        }
+        parentNum = patch.parent_task_id === null ? undefined : patch.parent_task_id;
+      }
+      const reread = await store.getTask(nativeId) ?? updated;
+      if (parentNum === undefined && reread.parent_id) {
+        const nums = await parentNumMap();
+        parentNum = nums.get(reread.parent_id);
+      }
+      return toStoredTask(reread, vocabulary, parentNum);
+    },
+    async deleteTask(nativeId) {
+      return await store.deleteTask(nativeId);
+    },
+    async createOperation(input) {
+      const op = await store.appendOperation({
+        task_id: input.taskNativeId ?? String(input.taskId),
+        type: operationType,
+        data: {
+          taskId: input.taskId,
+          sessionId: input.sessionId,
+          milestoneType: input.milestoneType,
+          milestoneTitle: input.milestoneTitle,
+          milestoneDescription: input.milestoneDescription,
+          processDescription: input.processDescription,
+          ...input.mdPath ? { mdPath: input.mdPath } : {}
+        }
+      });
+      return toStoredOperation(op);
+    },
+    async listOperations(request) {
+      const res = await store.listOperations({
+        ...request?.taskNativeId ? { task_id: request.taskNativeId } : {},
+        type: operationType,
+        limit: request?.limit ?? scanLimit,
+        offset: request?.offset ?? 0
+      });
+      return { operations: res.operations.map(toStoredOperation), total: res.total };
+    },
+    async getOperationByNum(num) {
+      if (typeof store.getOperationByNum !== "function")
+        return null;
+      const op = await store.getOperationByNum(num);
+      return op ? toStoredOperation(op) : null;
+    },
+    async updateOperationByNum(num, patch) {
+      if (typeof store.updateOperation !== "function")
+        return null;
+      if (typeof store.getOperationByNum !== "function")
+        return null;
+      const existing = await store.getOperationByNum(num);
+      if (!existing)
+        return null;
+      const previous = toStoredOperation(existing);
+      const updated = await store.updateOperation(num, {
+        data: {
+          taskId: previous.taskId,
+          sessionId: patch.sessionId ?? previous.sessionId,
+          milestoneType: patch.milestoneType ?? previous.milestoneType,
+          milestoneTitle: patch.milestoneTitle ?? previous.milestoneTitle,
+          milestoneDescription: patch.milestoneDescription ?? previous.milestoneDescription,
+          processDescription: patch.processDescription ?? previous.processDescription,
+          ...patch.mdPath ?? previous.mdPath ? { mdPath: patch.mdPath ?? previous.mdPath } : {}
+        }
+      });
+      return updated ? toStoredOperation(updated) : null;
+    },
+    async deleteOperationByNum(num) {
+      if (typeof store.deleteOperation !== "function")
+        return false;
+      return await store.deleteOperation(num);
+    }
+  };
+}
+export {
+  toNumericHandle,
+  mergeDeliverableIntoContext,
+  formatDeliverableForOperation,
+  createSQLiteTaskPort,
+  createRoySidecarTaskPort,
+  allowedIdsByDepth,
+  TaskStoreBackend,
+  DELIVERABLE_OPERATION_PREFIX
+};