pi-webdesk 0.1.0

package/dist/apps/daemon/src/workspace.js

@@ -0,0 +1,795 @@
+// apps/daemon/src/workspace.ts
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import {
+  GitWorktreeIncompleteError,
+  createTaskWorktree,
+  inspectRepository,
+  isGitServiceError,
+  preflightTaskWorktree
+} from "../../../packages/git/src/index.js";
+import {
+  PROTOCOL_VERSION,
+  workspaceSnapshotSchema,
+  workspaceStateSchema
+} from "../../../packages/protocol/src/index.js";
+import { createWorkspaceStore } from "./workspace-store.js";
+var WorkspaceOperationError = class extends Error {
+  name = "WorkspaceOperationError";
+  code;
+  status;
+  constructor(code, message, status, options) {
+    super(message, options);
+    this.code = code;
+    this.status = status;
+  }
+};
+function snapshot(state) {
+  return workspaceSnapshotSchema.parse({
+    protocol: PROTOCOL_VERSION,
+    type: "workspace-snapshot",
+    state
+  });
+}
+function slugify(title) {
+  const slug = title.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48).replace(/-+$/g, "");
+  return slug || "task";
+}
+var CONFLICT_CODES = /* @__PURE__ */ new Set([
+  "GIT_BRANCH_EXISTS",
+  "GIT_WORKTREE_TARGET_EXISTS",
+  "GIT_WORKTREE_TARGET_REGISTERED"
+]);
+function gitError(error) {
+  if (error instanceof GitWorktreeIncompleteError) {
+    return new WorkspaceOperationError(
+      "git-incomplete",
+      "Git may have created only part of the task worktree. Webdesk preserved it for recovery.",
+      409,
+      { cause: error }
+    );
+  }
+  if (isGitServiceError(error)) {
+    return new WorkspaceOperationError(
+      CONFLICT_CODES.has(error.code) ? "git-conflict" : "git-preflight-failed",
+      error.message,
+      CONFLICT_CODES.has(error.code) ? 409 : 422,
+      { cause: error }
+    );
+  }
+  if (error instanceof WorkspaceOperationError) {
+    return error;
+  }
+  return new WorkspaceOperationError(
+    "workspace-unavailable",
+    "The local workspace service could not complete the operation.",
+    503,
+    { cause: error }
+  );
+}
+function failedTask(task, error) {
+  const mapped = gitError(error);
+  const recoveryFacts = error instanceof GitWorktreeIncompleteError ? error.facts : void 0;
+  return {
+    id: task.id,
+    repositoryId: task.repositoryId,
+    title: task.title,
+    branch: task.branch,
+    worktreePath: task.worktreePath,
+    baseCommit: task.baseCommit,
+    createdAtMs: task.createdAtMs,
+    status: "failed",
+    failure: {
+      code: mapped.code,
+      message: mapped.message,
+      ...recoveryFacts ? { recoveryFacts } : {}
+    }
+  };
+}
+function interruptedTask(task, targetExistsOnDisk) {
+  return {
+    ...task,
+    status: "failed",
+    failure: {
+      code: "interrupted-provisioning",
+      message: "The daemon stopped while this worktree was being created. Inspect the branch and path before recovering it.",
+      recoveryFacts: {
+        branch: task.branch,
+        worktreePath: task.worktreePath,
+        baseCommit: task.baseCommit,
+        branchExists: null,
+        targetRegisteredAsWorktree: null,
+        targetExistsOnDisk
+      }
+    }
+  };
+}
+function createWorkspaceService(options) {
+  const stateDir = path.resolve(options.stateDir);
+  const store = options.store ?? createWorkspaceStore({ stateDir });
+  const git = options.git ?? {
+    inspectRepository,
+    preflightTaskWorktree,
+    createTaskWorktree
+  };
+  const now = options.now ?? Date.now;
+  const createId = options.createId ?? randomUUID;
+  let initialization = null;
+  let canonicalStateRoot = null;
+  function expectedTaskWorktreePath(repositoryId, taskId) {
+    if (canonicalStateRoot === null) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "Webdesk could not resolve its canonical state directory.",
+        503
+      );
+    }
+    return path.join(canonicalStateRoot, "worktrees", repositoryId, taskId);
+  }
+  async function ensureRealOwnedDirectory(directoryPath) {
+    try {
+      await mkdir(directoryPath, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const state = await lstat(directoryPath);
+    if (!state.isDirectory() || state.isSymbolicLink()) {
+      throw new Error(`${directoryPath} is not a real directory`);
+    }
+    if (await realpath(directoryPath) !== directoryPath) {
+      throw new Error(`${directoryPath} resolves outside its canonical location`);
+    }
+  }
+  async function prepareTaskWorktreeParent(repositoryId) {
+    if (canonicalStateRoot === null) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "Webdesk could not resolve its canonical state directory.",
+        503
+      );
+    }
+    try {
+      const worktreesRoot = path.join(canonicalStateRoot, "worktrees");
+      await ensureRealOwnedDirectory(worktreesRoot);
+      await ensureRealOwnedDirectory(path.join(worktreesRoot, repositoryId));
+    } catch (error) {
+      throw new WorkspaceOperationError(
+        "git-preflight-failed",
+        "Webdesk refused the task because its daemon-owned worktree parent is missing, symlinked, or outside the canonical state directory.",
+        409,
+        { cause: error }
+      );
+    }
+  }
+  async function reconcileProvisioningTask(task, state, canonicalStateDir) {
+    let canonicalWorktreePath;
+    try {
+      canonicalWorktreePath = await realpath(task.worktreePath);
+    } catch (error) {
+      const code = error.code;
+      return interruptedTask(task, code === "ENOENT" || code === "ENOTDIR" ? false : null);
+    }
+    const expectedWorktreePath = path.join(
+      canonicalStateDir,
+      "worktrees",
+      task.repositoryId,
+      task.id
+    );
+    if (canonicalWorktreePath !== expectedWorktreePath) return interruptedTask(task, true);
+    const repository = state.repositories.find((record) => record.id === task.repositoryId);
+    if (!repository) return interruptedTask(task, true);
+    try {
+      const worktree = await git.inspectRepository(canonicalWorktreePath);
+      if (worktree.root === canonicalWorktreePath && worktree.commonDir === repository.commonDir && worktree.branch === task.branch && worktree.headCommit === task.baseCommit) {
+        return { ...task, worktreePath: canonicalWorktreePath, status: "ready" };
+      }
+    } catch {
+    }
+    return interruptedTask(task, true);
+  }
+  async function canonicalizeRecordedTaskPath(task, state, canonicalStateDir) {
+    if (task.status !== "ready" && task.status !== "archived") return task;
+    const expectedWorktreePath = path.join(
+      canonicalStateDir,
+      "worktrees",
+      task.repositoryId,
+      task.id
+    );
+    const legacyConfiguredPath = path.join(
+      stateDir,
+      "worktrees",
+      task.repositoryId,
+      task.id
+    );
+    let canonicalWorktreePath;
+    try {
+      canonicalWorktreePath = await realpath(task.worktreePath);
+    } catch {
+      if (task.worktreePath !== expectedWorktreePath && task.worktreePath !== legacyConfiguredPath) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          `Task ${task.id} records a path outside its daemon-owned worktree slot. Webdesk preserved the workspace metadata and refused startup.`,
+          503
+        );
+      }
+      return task;
+    }
+    if (canonicalWorktreePath !== expectedWorktreePath) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        `Task ${task.id} resolves outside its daemon-owned worktree path. Webdesk preserved the workspace metadata and refused startup.`,
+        503
+      );
+    }
+    if (canonicalWorktreePath === task.worktreePath) return task;
+    const repository = state.repositories.find((record) => record.id === task.repositoryId);
+    if (repository === void 0) return task;
+    try {
+      const worktree = await git.inspectRepository(canonicalWorktreePath);
+      if (worktree.root === canonicalWorktreePath && worktree.commonDir === repository.commonDir && worktree.branch === task.branch) {
+        return { ...task, worktreePath: canonicalWorktreePath };
+      }
+    } catch {
+    }
+    return task;
+  }
+  async function verifyTaskWorktree(taskId) {
+    await initialize();
+    const state = await store.read();
+    const task = state.tasks.find((candidate) => candidate.id === taskId);
+    if (task === void 0 || task.status !== "ready") {
+      throw new WorkspaceOperationError(
+        task === void 0 ? "task-not-found" : "task-not-ready",
+        "Only a ready task can start Pi.",
+        task === void 0 ? 404 : 409
+      );
+    }
+    const expectedWorktreePath = expectedTaskWorktreePath(task.repositoryId, task.id);
+    if (task.worktreePath !== expectedWorktreePath) {
+      throw new WorkspaceOperationError(
+        "task-recovery-required",
+        "The task worktree is not recorded at its daemon-owned canonical path.",
+        409
+      );
+    }
+    const repository = state.repositories.find((candidate) => candidate.id === task.repositoryId);
+    if (repository === void 0) {
+      throw new WorkspaceOperationError(
+        "task-recovery-required",
+        "The task's registered repository is unavailable.",
+        409
+      );
+    }
+    let canonicalWorktreePath;
+    let worktree;
+    try {
+      canonicalWorktreePath = await realpath(task.worktreePath);
+      if (canonicalWorktreePath !== expectedWorktreePath) throw new Error("worktree retargeted");
+      worktree = await git.inspectRepository(canonicalWorktreePath);
+      if (await realpath(task.worktreePath) !== canonicalWorktreePath) {
+        throw new Error("worktree changed while it was being verified");
+      }
+    } catch (error) {
+      throw new WorkspaceOperationError(
+        "task-recovery-required",
+        "The task worktree is unavailable or no longer at its daemon-owned canonical path.",
+        409,
+        { cause: error }
+      );
+    }
+    if (worktree.root !== canonicalWorktreePath || worktree.commonDir !== repository.commonDir || worktree.branch !== task.branch) {
+      throw new WorkspaceOperationError(
+        "task-recovery-required",
+        "The task worktree no longer matches its recorded repository or branch.",
+        409
+      );
+    }
+    return canonicalWorktreePath;
+  }
+  function initialize() {
+    initialization ??= (async () => {
+      await store.initialize();
+      const current = await store.read();
+      const canonicalStateDir = await realpath(stateDir);
+      canonicalStateRoot = canonicalStateDir;
+      const reconciled = await Promise.all(
+        current.tasks.map(async (task) => {
+          if (task.status === "provisioning") {
+            return reconcileProvisioningTask(task, current, canonicalStateDir);
+          }
+          return canonicalizeRecordedTaskPath(task, current, canonicalStateDir);
+        })
+      );
+      if (reconciled.every((task, index) => task === current.tasks[index])) return;
+      const byId = new Map(reconciled.map((task) => [task.id, task]));
+      await store.update((state) => ({
+        ...state,
+        tasks: state.tasks.map((task) => byId.get(task.id) ?? task)
+      }));
+    })();
+    return initialization;
+  }
+  async function registerRepository(request) {
+    await initialize();
+    let repository;
+    try {
+      repository = await git.inspectRepository(request.path);
+    } catch (error) {
+      throw gitError(error);
+    }
+    const next = await store.update((current) => {
+      const existing = current.repositories.find(
+        (record) => record.commonDir === repository.commonDir
+      );
+      if (existing) {
+        if (existing.rootPath !== repository.root) {
+          throw new WorkspaceOperationError(
+            "repository-already-registered",
+            `This Git repository is already registered through ${existing.rootPath}.`,
+            409
+          );
+        }
+        return {
+          ...current,
+          repositories: current.repositories.map(
+            (record) => record.id === existing.id ? {
+              ...record,
+              headCommit: repository.headCommit,
+              branch: repository.branch
+            } : record
+          )
+        };
+      }
+      return {
+        ...current,
+        repositories: [
+          ...current.repositories,
+          {
+            id: createId(),
+            rootPath: repository.root,
+            commonDir: repository.commonDir,
+            displayName: path.basename(repository.root) || repository.root,
+            headCommit: repository.headCommit,
+            branch: repository.branch,
+            createdAtMs: now()
+          }
+        ]
+      };
+    });
+    return snapshot(next);
+  }
+  async function provisionTask(request, prepared) {
+    await initialize();
+    const current = await store.read();
+    const repository = current.repositories.find((record) => record.id === request.repositoryId);
+    if (!repository) {
+      throw new WorkspaceOperationError(
+        "repository-not-found",
+        "The selected repository is no longer registered.",
+        404
+      );
+    }
+    const taskId = prepared?.taskId ?? createId();
+    if (current.tasks.some((task) => task.id === taskId)) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "Webdesk could not reserve a unique task identity.",
+        503
+      );
+    }
+    const branch = `pita/${slugify(request.title)}-${taskId.slice(0, 8)}`;
+    const expectedWorktreePath = expectedTaskWorktreePath(repository.id, taskId);
+    await prepareTaskWorktreeParent(repository.id);
+    const worktreePath = expectedWorktreePath;
+    let plan;
+    try {
+      plan = await git.preflightTaskWorktree({
+        repositoryPath: repository.rootPath,
+        baseRef: request.baseRef,
+        branch,
+        worktreePath
+      });
+    } catch (error) {
+      throw gitError(error);
+    }
+    const provisioning = {
+      id: taskId,
+      repositoryId: repository.id,
+      title: request.title.trim(),
+      branch,
+      worktreePath,
+      baseCommit: plan.baseCommit,
+      createdAtMs: now(),
+      status: "provisioning"
+    };
+    await store.update((state) => ({
+      ...state,
+      tasks: [...state.tasks, provisioning]
+    }));
+    try {
+      const created = await git.createTaskWorktree({
+        repositoryPath: repository.rootPath,
+        baseRef: plan.baseCommit,
+        branch,
+        worktreePath
+      });
+      if (created.worktree.root !== expectedWorktreePath) {
+        throw new GitWorktreeIncompleteError(
+          "created worktree escaped the daemon-owned canonical state directory; nothing was cleaned up automatically",
+          {
+            branch,
+            worktreePath,
+            baseCommit: plan.baseCommit,
+            branchExists: true,
+            targetRegisteredAsWorktree: true,
+            targetExistsOnDisk: true
+          }
+        );
+      }
+      provisioning.worktreePath = created.worktree.root;
+    } catch (error) {
+      try {
+        await store.update((state) => ({
+          ...state,
+          tasks: state.tasks.map((task) => task.id === taskId ? failedTask(task, error) : task)
+        }));
+      } catch {
+        throw gitError(error);
+      }
+      throw gitError(error);
+    }
+    let piSessionFile;
+    let preparationError = null;
+    if (prepared !== void 0) {
+      try {
+        const result = await prepared.prepare({ ...provisioning, status: "provisioning" });
+        if (!path.isAbsolute(result.piSessionFile)) {
+          throw new Error("Pi returned a non-absolute child session path");
+        }
+        piSessionFile = path.normalize(result.piSessionFile);
+      } catch (error) {
+        preparationError = error;
+      }
+    }
+    let ready;
+    try {
+      ready = await store.update((state) => ({
+        ...state,
+        tasks: state.tasks.map(
+          (task) => task.id === taskId ? {
+            ...provisioning,
+            status: "ready",
+            ...piSessionFile === void 0 ? {} : { piSessionFile }
+          } : task
+        )
+      }));
+    } catch (error) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "The worktree was created and verified, but Webdesk could not record it as ready. Restart the daemon to reconcile the task safely.",
+        503,
+        { cause: error }
+      );
+    }
+    return {
+      snapshot: snapshot(workspaceStateSchema.parse(ready)),
+      taskId,
+      preparationError
+    };
+  }
+  async function createTask(request) {
+    return (await provisionTask(request)).snapshot;
+  }
+  async function createPreparedTask(request, options2) {
+    return provisionTask(request, options2);
+  }
+  async function archiveTask(taskId) {
+    await initialize();
+    const next = await store.update((state) => {
+      const taskIndex = state.tasks.findIndex((candidate) => candidate.id === taskId);
+      const task = state.tasks[taskIndex];
+      if (task === void 0) {
+        throw new WorkspaceOperationError(
+          "task-not-found",
+          "The selected task no longer exists.",
+          404
+        );
+      }
+      if (task.status === "archived") return state;
+      if (task.status !== "ready") {
+        throw new WorkspaceOperationError(
+          "task-not-ready",
+          `Only a ready task can be archived; this task is ${task.status}.`,
+          409
+        );
+      }
+      if (task.runtimeProcess !== void 0) {
+        throw new WorkspaceOperationError(
+          "task-recovery-required",
+          "Webdesk could not prove that the task runtime stopped cleanly, so the task was not archived.",
+          409
+        );
+      }
+      const archivedAtMs = now();
+      const { status: _status, runtimeProcess: _runtimeProcess, ...preserved } = task;
+      const archived = {
+        ...preserved,
+        status: "archived",
+        archivedAtMs
+      };
+      return {
+        ...state,
+        tasks: state.tasks.map((candidate, index) => index === taskIndex ? archived : candidate)
+      };
+    });
+    return snapshot(next);
+  }
+  async function restoreTask(taskId, archivedAtMs) {
+    await initialize();
+    const next = await store.update((state) => {
+      const taskIndex = state.tasks.findIndex((candidate) => candidate.id === taskId);
+      const task = state.tasks[taskIndex];
+      if (task === void 0) {
+        throw new WorkspaceOperationError(
+          "task-not-found",
+          "The selected task no longer exists.",
+          404
+        );
+      }
+      if (task.status === "ready") return state;
+      if (task.status !== "archived") {
+        throw new WorkspaceOperationError(
+          "task-not-ready",
+          `Only an archived task can be restored; this task is ${task.status}.`,
+          409
+        );
+      }
+      if (task.archivedAtMs !== archivedAtMs) {
+        throw new WorkspaceOperationError(
+          "task-busy",
+          "The archived task changed while restore was being verified. Retry from the refreshed workspace.",
+          409
+        );
+      }
+      const { status: _status, archivedAtMs: _archivedAtMs, ...preserved } = task;
+      const restored = { ...preserved, status: "ready" };
+      return {
+        ...state,
+        tasks: state.tasks.map((candidate, index) => index === taskIndex ? restored : candidate)
+      };
+    });
+    return snapshot(next);
+  }
+  async function recordTaskSession(taskId, sessionFile) {
+    await initialize();
+    if (!path.isAbsolute(sessionFile)) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "Pi reported a non-absolute session path, so Webdesk did not associate it with the task.",
+        503
+      );
+    }
+    const normalizedSessionFile = path.normalize(sessionFile);
+    await store.update((state) => {
+      const task = state.tasks.find((candidate) => candidate.id === taskId);
+      if (task === void 0) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "The task disappeared before its Pi session could be recorded.",
+          503
+        );
+      }
+      if (task.status !== "ready") {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Only a ready task can own a Pi session.",
+          503
+        );
+      }
+      if (task.piSessionFile !== void 0 && task.piSessionFile !== normalizedSessionFile) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Pi reported a different session file for a task that already owns one.",
+          503
+        );
+      }
+      if (task.piSessionFile === normalizedSessionFile) return state;
+      return {
+        ...state,
+        tasks: state.tasks.map(
+          (candidate) => candidate.id === taskId ? { ...candidate, piSessionFile: normalizedSessionFile } : candidate
+        )
+      };
+    });
+  }
+  async function claimTaskRuntimeGeneration(taskId) {
+    await initialize();
+    let claimedGeneration = null;
+    await store.update((state) => {
+      const task = state.tasks.find((candidate) => candidate.id === taskId);
+      if (task === void 0) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "The task disappeared before its runtime generation could be reserved.",
+          503
+        );
+      }
+      if (task.status !== "ready") {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Only a ready task can reserve a runtime generation.",
+          503
+        );
+      }
+      if (task.runtimeProcess !== void 0) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "A previously supervised Pi process must be recovered before starting another runtime.",
+          503
+        );
+      }
+      const nextGeneration = (task.runtimeGeneration ?? 0) + 1;
+      if (!Number.isSafeInteger(nextGeneration)) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "The task runtime generation counter is exhausted.",
+          503
+        );
+      }
+      claimedGeneration = nextGeneration;
+      return {
+        ...state,
+        tasks: state.tasks.map(
+          (candidate) => candidate.id === taskId ? { ...candidate, runtimeGeneration: nextGeneration } : candidate
+        )
+      };
+    });
+    if (claimedGeneration === null) {
+      throw new WorkspaceOperationError(
+        "workspace-unavailable",
+        "The runtime generation reservation did not complete.",
+        503
+      );
+    }
+    return claimedGeneration;
+  }
+  async function recordTaskRuntimeProcess(taskId, process) {
+    await initialize();
+    await store.update((state) => {
+      const task = state.tasks.find((candidate) => candidate.id === taskId);
+      if (task === void 0 || task.status !== "ready") {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Only a ready task can own a supervised Pi process.",
+          503
+        );
+      }
+      if (task.runtimeGeneration !== process.runtimeGeneration) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "The Pi process belongs to a stale runtime generation.",
+          503
+        );
+      }
+      if (task.runtimeProcess !== void 0) {
+        if (task.runtimeProcess.runtimeGeneration === process.runtimeGeneration && task.runtimeProcess.pid === process.pid && task.runtimeProcess.startFingerprint === process.startFingerprint) {
+          return state;
+        }
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Another supervised Pi process is still recorded for this task.",
+          503
+        );
+      }
+      return {
+        ...state,
+        tasks: state.tasks.map(
+          (candidate) => candidate.id === taskId ? { ...candidate, runtimeProcess: process } : candidate
+        )
+      };
+    });
+  }
+  async function clearTaskRuntimeProcess(taskId, generation, pid) {
+    await initialize();
+    await store.update((state) => {
+      const task = state.tasks.find((candidate) => candidate.id === taskId);
+      if (task === void 0 || task.status !== "ready" || task.runtimeProcess === void 0 || task.runtimeProcess.runtimeGeneration !== generation || task.runtimeProcess.pid !== pid) {
+        return state;
+      }
+      const { runtimeProcess: _removed, ...withoutProcess } = task;
+      return {
+        ...state,
+        tasks: state.tasks.map(
+          (candidate) => candidate.id === taskId ? withoutProcess : candidate
+        )
+      };
+    });
+  }
+  async function recordTaskValidation(taskId, result) {
+    await initialize();
+    await store.update((state) => {
+      const task = state.tasks.find((candidate) => candidate.id === taskId);
+      if (task === void 0 || task.status !== "ready") {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Only a ready task can record a validation result.",
+          503
+        );
+      }
+      return {
+        ...state,
+        tasks: state.tasks.map(
+          (candidate) => candidate.id === taskId ? { ...candidate, validation: result } : candidate
+        )
+      };
+    });
+  }
+  async function recordPendingMerge(repositoryId, record) {
+    await initialize();
+    await store.update((state) => {
+      const repository = state.repositories.find((candidate) => candidate.id === repositoryId);
+      if (repository === void 0) {
+        throw new WorkspaceOperationError(
+          "repository-not-found",
+          "The repository disappeared before its merge intent could be recorded.",
+          409
+        );
+      }
+      if (repository.pendingMerge !== void 0 && repository.pendingMerge.preflightId !== record.preflightId) {
+        throw new WorkspaceOperationError(
+          "workspace-unavailable",
+          "Another interrupted merge is still pending recovery for this repository.",
+          409
+        );
+      }
+      return {
+        ...state,
+        repositories: state.repositories.map(
+          (candidate) => candidate.id === repositoryId ? { ...candidate, pendingMerge: record } : candidate
+        )
+      };
+    });
+  }
+  async function clearPendingMerge(repositoryId, preflightId, resolvedHead) {
+    await initialize();
+    await store.update((state) => {
+      const repository = state.repositories.find((candidate) => candidate.id === repositoryId);
+      if (repository === void 0 || repository.pendingMerge === void 0 || repository.pendingMerge.preflightId !== preflightId) {
+        return state;
+      }
+      return {
+        ...state,
+        repositories: state.repositories.map((candidate) => {
+          if (candidate.id !== repositoryId) return candidate;
+          const { pendingMerge: _removed, ...withoutPending } = candidate;
+          return resolvedHead === void 0 ? withoutPending : { ...withoutPending, headCommit: resolvedHead };
+        })
+      };
+    });
+  }
+  return {
+    initialize,
+    async snapshot() {
+      await initialize();
+      return snapshot(await store.read());
+    },
+    registerRepository,
+    createTask,
+    createPreparedTask,
+    verifyTaskWorktree,
+    archiveTask,
+    restoreTask,
+    recordTaskSession,
+    claimTaskRuntimeGeneration,
+    recordTaskRuntimeProcess,
+    clearTaskRuntimeProcess,
+    recordTaskValidation,
+    recordPendingMerge,
+    clearPendingMerge
+  };
+}
+export {
+  WorkspaceOperationError,
+  createWorkspaceService
+};