Blame for src/claws/lifecycle-state.ts

import { isDeepStrictEqual } from "node:util";
import { coerceErrorMessage } from "@openclaw/normalization-core";
import {
  AgentSharedStoreOwnerError,
  assertAgentSessionStoreDeletionSafe,
  isPathOwnedBySurvivingAgent,
  readAgentDeleteDatabaseRegistry,
  resolveSurvivingDatabaseFilePaths,
} from "../agents/agent-delete-databases.js";
import { getRuntimeConfig } from "../config/config.js";
import { clawCronGatewayJobMatchesRef, deleteClawCronRef, markClawCronRefRemoved } from "./cron.js";
import {
  clawBootstrapStateBlocksRemove,
  planClawBootstrapRemoval,
  removeClawBootstrap,
} from "./lifecycle-bootstrap-removal.js";
import {
  withClawAgentConfigRemoval,
  digestClawAgentRemovalSurface,
} from "./lifecycle-config-removal.js";
import {
  clawRemoveQuietRuntime,
  ClawRemoveError,
  cleanupClawAgentFilesystem,
  deletionEffects,
  readClawRemoveCronInventory,
  releaseClawRemoveRows,
  removeClawWorkspaceFile,
  workspaceContainsUntrackedEntries,
} from "./lifecycle-delete-support.js";
import { removeClawMcpServers } from "./lifecycle-mcp-removal.js";
import {
  CLAW_REMOVE_PLAN_SCHEMA_VERSION,
  CLAW_REMOVE_RESULT_SCHEMA_VERSION,
  type ClawRemoveApplyOptions,
  type ClawRemovePlanOptions,
  type ClawRemoveResult,
  type ClawRemovePlan,
  type ClawRemovePlanAction,
} from "./lifecycle-remove-contract.js";
import { readClawStatus } from "./lifecycle-status.js";
import { clawMcpRemovalSelector, planClawMcpServerRemoval } from "./mcp.js";
import { clawMonitorSnapshotSchema } from "./monitor-cleanup-contract.js";
import { applyClawPackageRemovalPhase } from "./package-remove-phase.js";
import {
  filterReferencedCleanup,
  projectClawPackageRemovePlan,
  digestClawRemovalState,
} from "./package-remove-plan.js";
import { planClawPackageRemovals } from "./package-remove.js";
import { CLAW_OUTPUT_STABILITY } from "./types.js";

export { ClawRemoveError } from "./lifecycle-delete-support.js";
export {
  CLAW_REMOVE_PLAN_SCHEMA_VERSION,
  CLAW_REMOVE_RESULT_SCHEMA_VERSION,
} from "./lifecycle-remove-contract.js";
export { readClawStatus, type ClawStatusRecord } from "./lifecycle-status.js";

export async function buildClawRemovePlan(
  target: string,
  options: ClawRemovePlanOptions = {},
): Promise<ClawRemovePlan> {
  const status = await readClawStatus(target, options);
  const blockers: ClawRemovePlan["blockers"] = [];
  if (status.records.length === 0) {
    blockers.push({
      code: "claw_not_found",
      message: `No installed Claw matches ${JSON.stringify(target)}.`,
    });
  } else if (status.records.length > 1) {
    blockers.push({
      code: "claw_ambiguous",
      message: `Claw name ${JSON.stringify(target)} matches multiple agents; use an agent id.`,
    });
  }
  const record = status.records.length === 1 ? status.records[0] : undefined;
  if (record?.agentState === "modified") {
    blockers.push({
      code: "agent_modified",
      message: `Agent ${JSON.stringify(record.install.agentId)} changed after add.`,
    });
  }
  for (const file of record?.workspaceFiles ?? []) {
    if (file.state === "unsafe") {
      blockers.push({
        code: "workspace_file_unsafe",
        message: `${file.path}: ${file.message ?? "unsafe file"}`,
      });
    }
  }
  if (record && clawBootstrapStateBlocksRemove(record)) {
    blockers.push({
      code: "bootstrap_cleanup_uncertain",
      message: `BOOTSTRAP.md has ${record.bootstrap.state} ownership state and must be reconciled before removal.`,
    });
  }
  for (const server of record?.mcpServers ?? []) {
    if (server.state === "pending") {
      blockers.push({
        code: "mcp_cleanup_uncertain",
        message: `MCP server ${JSON.stringify(server.name)} has ${server.state} ownership state and must be reconciled before removal.`,
      });
    }
  }
  for (const cron of record?.cronJobs ?? []) {
    if (cron.status !== "removed" && (cron.status !== "complete" || !cron.schedulerJobId)) {
      blockers.push({
        code: "cron_cleanup_uncertain",
        message: `Cron declaration ${JSON.stringify(cron.manifestId)} has ${cron.status} ownership state and must be reconciled before removal.`,
      });
    }
  }
  const actions: ClawRemovePlanAction[] = [];
  if (record) {
    const packageCleanup = filterReferencedCleanup(options.referencedCleanup, "package");
    const mcpCleanup = filterReferencedCleanup(options.referencedCleanup, "mcp");
    const packageDecisions = await planClawPackageRemovals(record.install, record.packages, {
      ...options,
      deps: options.packageDeps,
      referencedCleanup: packageCleanup,
    });
    const packagePlan = projectClawPackageRemovePlan({
      decisions: packageDecisions,
      inspections: record.packages,
      cleanup: packageCleanup,
    });
    blockers.push(...packagePlan.blockers);
    const config = options.config ?? getRuntimeConfig();
    try {
      assertAgentSessionStoreDeletionSafe(config, record.install.agentId, options);
    } catch (error) {
      if (!(error instanceof AgentSharedStoreOwnerError)) {
        throw error;
      }
      blockers.push({ code: "shared_session_store_owner", message: error.message });
    }
    const effects = deletionEffects(
      config,
      record.install.agentId,
      record.install.workspace,
      options.env,
    );
    const survivingDatabaseFilePaths = resolveSurvivingDatabaseFilePaths(
      readAgentDeleteDatabaseRegistry(options),
      record.install.agentId,
      options.env,
    );
    const sharedWithSurvivor = (pathname: string) =>
      isPathOwnedBySurvivingAgent(
        config,
        record.install.agentId,
        pathname,
        survivingDatabaseFilePaths,
        options.env,
      );
    const sharedWorkspace = Boolean(effects.workspace) && sharedWithSurvivor(effects.workspace);
    const sharedAgentDir = sharedWithSurvivor(effects.agentDir);
    const sharedSessionsDir = sharedWithSurvivor(effects.sessionsDir);
    const workspaceHasModifiedFiles =
      record.workspaceFiles.some((file) => file.state === "modified") ||
      record.bootstrap.state === "modified";
    const trackedWorkspacePaths = [
      ...record.workspaceFiles.map((file) => file.path),
      ...(record.install.bootstrap && record.bootstrap.state === "pending"
        ? [record.bootstrap.path]
        : []),
    ];
    const workspaceHasUntrackedEntries = await workspaceContainsUntrackedEntries(
      record.install.workspace,
      trackedWorkspacePaths,
    );
    const { attachedJobs, monitors, inspectionUnavailable } = await readClawRemoveCronInventory(
      record.install.agentId,
      options,
    );
    const ownedSchedulerJobIds = new Set(
      record.cronJobs
        .filter((cron) => cron.status !== "removed" && cron.schedulerJobId)
        .map((cron) => cron.schedulerJobId),
    );
    actions.push({
      kind: "agent",
      id: record.install.agentId,
      action: "remove",
      target: `agents.entries[${JSON.stringify(record.install.agentId)}]`,
      blocked: record.agentState === "modified",
      details: {
        expectedState: record.agentState,
        configDigest: record.install.agentConfigDigest,
        removalSurfaceDigest: digestClawAgentRemovalSurface(
          options.config ?? getRuntimeConfig(),
          record.install.agentId,
        ),
        ownedPaths: record.install.agentOwnedPaths,
      },
      ...(record.agentState === "modified" ? { reason: "Agent config digest changed." } : {}),
    });
    if (effects.pruned.removedBindings > 0) {
      actions.push({
        kind: "configBinding",
        id: record.install.agentId,
        action: "remove",
        target: `bindings[agentId=${record.install.agentId}]`,
        blocked: record.agentState === "modified",
        details: { count: effects.pruned.removedBindings },
      });
    }
    if (effects.pruned.removedAllow > 0) {
      actions.push({
        kind: "agentAllow",
        id: record.install.agentId,
        action: "remove",
        target: `tools.agentToAgent.allow[${record.install.agentId}]`,
        blocked: record.agentState === "modified",
        details: { count: effects.pruned.removedAllow },
      });
    }
    if (effects.workspace) {
      actions.push({
        kind: "workspace",
        id: record.install.agentId,
        action:
          sharedWorkspace || workspaceHasModifiedFiles || workspaceHasUntrackedEntries
            ? "retain"
            : "trash",
        target: effects.workspace,
        blocked: record.agentState === "modified",
        details: {
          retained: sharedWorkspace || workspaceHasModifiedFiles || workspaceHasUntrackedEntries,
          sharedWith: effects.workspaceSharedWith,
        },
        ...(sharedWorkspace
          ? { reason: "Workspace contains state owned by another agent." }
          : workspaceHasModifiedFiles
            ? { reason: "Workspace contains locally modified Claw-managed files." }
            : workspaceHasUntrackedEntries
              ? { reason: "Workspace contains files or directories not managed by this Claw." }
              : {}),
      });
    }
    if (effects.agentDir) {
      actions.push({
        kind: "agentState",
        id: record.install.agentId,
        action: sharedAgentDir ? "retain" : "trash",
        target: effects.agentDir,
        blocked: record.agentState === "modified",
        ...(sharedAgentDir
          ? { reason: "Agent directory contains state owned by another agent." }
          : {}),
      });
    }
    actions.push({
      kind: "sessionIndex",
      id: record.install.agentId,
      action: "delete",
      target: `session store entries for agent:${record.install.agentId}`,
      blocked: record.agentState === "modified",
    });
    actions.push({
      kind: "sessionTranscripts",
      id: record.install.agentId,
      action: sharedSessionsDir ? "retain" : "trash",
      target: effects.sessionsDir,
      blocked: record.agentState === "modified",
      ...(sharedSessionsDir
        ? { reason: "Session directory contains state owned by another agent." }
        : {}),
    });
    for (const job of attachedJobs.filter((candidate) => !ownedSchedulerJobIds.has(candidate.id))) {
      if (monitors.some((monitor) => isDeepStrictEqual(monitor, job))) {
        actions.push({
          kind: "scheduledJob",
          id: job.id,
          action: "remove",
          target: `cron_jobs:${job.id}`,
          blocked: false,
          reason: "Config-owned monitor; Gateway cancellation and drainage precede local cleanup.",
          details: { ...job },
        });
        continue;
      }
      blockers.push({
        code: "agent_job_attached",
        message: `Cron job ${JSON.stringify(job.id)} still references agent ${JSON.stringify(record.install.agentId)}; reassign or remove independent work, or reconnect to the serving Gateway to verify monitor ownership.`,
      });
      actions.push({
        kind: "scheduledJob",
        id: job.id,
        action: "retain",
        target: `cron_jobs:${job.id}`,
        blocked: true,
        reason:
          "Scheduled work without verified Claw or config ownership must be handled explicitly.",
        details: {
          ...(inspectionUnavailable ? { monitorInspection: "unavailable" } : {}),
          name: job.name,
          enabled: job.enabled,
          agentId: job.agentId,
          ownerAgentId: job.ownerAgentId,
        },
      });
    }
    for (const file of record.workspaceFiles) {
      actions.push({
        kind: "workspaceFile",
        id: file.path,
        action: file.state === "unchanged" ? "delete" : "retain",
        target: `${file.workspace}:${file.path}`,
        blocked: file.state === "unsafe",
        details: {
          expectedState: file.state,
          contentDigest: file.contentDigest,
          workspace: file.workspace,
        },
        ...(file.state === "modified"
          ? { reason: "Local content changed; preserve the file." }
          : {}),
      });
    }
    const bootstrapAction = planClawBootstrapRemoval(record);
    if (bootstrapAction) {
      actions.push(bootstrapAction);
    }
    actions.push(...packagePlan.actions);
    const unmatchedMcpSelectors = new Set(mcpCleanup?.selected ?? []);
    for (const server of record.mcpServers) {
      const blocked = server.state === "pending";
      const decision = planClawMcpServerRemoval(server, {
        ...options,
        referencedCleanup: mcpCleanup,
      });
      unmatchedMcpSelectors.delete(clawMcpRemovalSelector(server));
      if (decision.blocked) {
        blockers.push({
          code: "referenced_cleanup_requires_override",
          message: `${clawMcpRemovalSelector(server)}: ${decision.reason ?? "explicit conflict override is required"}`,
        });
      }
      actions.push({
        kind: "mcpServer",
        id: server.name,
        action: blocked ? "retain" : decision.action,
        target: `mcp.servers.${server.name}`,
        blocked,
        details: {
          expectedState: server.state,
          configDigest: server.configDigest,
          relationship: server.relationship,
          origin: server.origin,
          independentOwner: server.independentOwner,
          affectedClawAgentIds: decision.affectedClawAgentIds,
          cleanupMode: mcpCleanup?.mode ?? "retain",
          availableCleanupModes:
            server.relationship === "referenced"
              ? ["retain", "remove-if-unused", "remove-selected"]
              : ["remove"],
        },
        ...(blocked
          ? { reason: `MCP ownership state is ${server.state}.` }
          : decision.reason
            ? { reason: decision.reason }
            : {}),
      });
    }
    for (const selector of unmatchedMcpSelectors) {
      blockers.push({
        code: "referenced_cleanup_not_found",
        message: `Selected referenced resource ${JSON.stringify(selector)} is not owned by this Claw.`,
      });
    }
    for (const cron of record.cronJobs) {
      const blocked =
        cron.status !== "removed" && (cron.status !== "complete" || !cron.schedulerJobId);
      actions.push({
        kind: "cronJob",
        id: cron.manifestId,
        action: blocked ? "retain" : "remove",
        target: cron.schedulerJobId ?? cron.declarationKey,
        blocked,
        details: {
          expectedStatus: cron.status,
          declarationKey: cron.declarationKey,
          schedulerJobId: cron.schedulerJobId,
          job: cron.job,
        },
        ...(blocked ? { reason: `Cron ownership state is ${cron.status}.` } : {}),
      });
    }
    actions.push({
      kind: "installRecord",
      id: record.install.agentId,
      action: "remove",
      target: `claw_installs:${record.install.agentId}`,
      blocked: false,
      details: {
        expectedStatus: record.install.status,
        planIntegrity: record.install.planIntegrity,
        sourceIntegrity: record.install.claw.integrity,
      },
    });
  }
  const planIdentity = {
    target,
    agentId: record?.install.agentId,
    actions,
    blockers,
  };
  return {
    schemaVersion: CLAW_REMOVE_PLAN_SCHEMA_VERSION,
    stability: CLAW_OUTPUT_STABILITY,
    dryRun: true,
    mutationAllowed: false,
    planIntegrity: digestClawRemovalState(planIdentity),
    target,
    ...(record ? { agentId: record.install.agentId } : {}),
    actions,
    blockers,
  };
}

export async function applyClawRemovePlan(
  plan: ClawRemovePlan,
  options: ClawRemoveApplyOptions = {},
): Promise<ClawRemoveResult> {
  if (options.consentPlanIntegrity !== plan.planIntegrity) {
    throw new ClawRemoveError(
      "plan_integrity_mismatch",
      "Consent does not match the current Claw remove plan; run remove --dry-run again.",
    );
  }
  if (plan.blockers.length > 0 || !plan.agentId) {
    throw new ClawRemoveError("remove_blocked", "The Claw remove plan contains blockers.");
  }
  const monitorGateway = options.monitorGateway;
  if (!monitorGateway) {
    throw new ClawRemoveError(
      "monitor_gateway_required",
      "Claw removal requires the serving Gateway to establish safe cancellation and drainage.",
    );
  }
  const currentPlan = await buildClawRemovePlan(plan.target, options);
  if (currentPlan.planIntegrity !== plan.planIntegrity) {
    throw new ClawRemoveError("remove_changed", "Claw-owned state changed after remove planning.");
  }
  const agentId = plan.agentId;
  const plannedAgentAction = plan.actions.find(
    (action) => action.kind === "agent" && action.id === agentId,
  );
  const expectedRemovalSurfaceDigest = plannedAgentAction?.details?.removalSurfaceDigest;
  if (typeof expectedRemovalSurfaceDigest !== "string") {
    throw new ClawRemoveError("remove_changed", "Claw remove plan is missing config state.");
  }
  const current = await readClawStatus(plan.agentId, options);
  const record = current.records[0];
  if (
    !record ||
    record.agentState === "modified" ||
    clawBootstrapStateBlocksRemove(record) ||
    record.workspaceFiles.some((file) => file.state === "unsafe") ||
    record.mcpServers.some((server) => server.state === "pending")
  ) {
    throw new ClawRemoveError("remove_changed", "Claw-owned state changed after remove planning.");
  }
  const packageDecisions = await planClawPackageRemovals(record.install, record.packages, {
    ...options,
    deps: options.packageDeps,
    referencedCleanup: filterReferencedCleanup(options.referencedCleanup, "package"),
  });
  const plannedPackages = plan.actions
    .filter((action) => action.kind === "packageRef")
    .map((action) => `${action.id}:${action.action}`)
    .toSorted();
  const currentPackages = packageDecisions
    .map(
      (decision) =>
        `${decision.packageRef.kind}:${decision.packageRef.ref}@${decision.packageRef.version}:${decision.action === "uninstall" ? "uninstall" : "release"}`,
    )
    .toSorted();
  if (JSON.stringify(plannedPackages) !== JSON.stringify(currentPackages)) {
    throw new ClawRemoveError("remove_changed", "Package ownership changed after remove planning.");
  }
  const plannedMcpServers = plan.actions
    .filter((action) => action.kind === "mcpServer")
    .map((action) => `${action.id}:${action.action}`)
    .toSorted();
  const currentMcpServers = record.mcpServers
    .map((server) => `${server.name}:${planClawMcpServerRemoval(server, options).action}`)
    .toSorted();
  if (JSON.stringify(plannedMcpServers) !== JSON.stringify(currentMcpServers)) {
    throw new ClawRemoveError("remove_changed", "MCP ownership changed after remove planning.");
  }
  const result: ClawRemoveResult = {
    schemaVersion: CLAW_REMOVE_RESULT_SCHEMA_VERSION,
    stability: CLAW_OUTPUT_STABILITY,
    dryRun: false,
    status: "partial",
    agentId,
    agentRemoved: false,
    workspaceFiles: [],
    packages: [],
    mcpServers: [],
    cronJobs: [],
    packageRefsReleased: 0,
  };
  const partial = (code: string, message: string): ClawRemoveResult => ({
    ...result,
    error: { code, message },
  });
  const monitors = currentPlan.actions
    .filter((action) => action.kind === "scheduledJob" && action.action === "remove")
    .map((action) => clawMonitorSnapshotSchema.parse(action.details));
  return await withClawAgentConfigRemoval<ClawRemoveResult>(
    {
      agentId,
      expectedDigest: record.install.agentConfigDigest,
      expectedInstall: record.orphaned ? null : record.install,
      expectedRemovalSurfaceDigest,
      expectedState: record.agentState,
      fallbackWorkspace: record.install.workspace,
      config: options.config,
      stateDatabase: options,
      onModified: () =>
        new ClawRemoveError("agent_modified", "Agent config changed during remove."),
      quiesceMonitors: (operationId) => monitorGateway.quiesce(agentId, operationId, monitors),
      drainMonitors: async (operationId) => await monitorGateway.drain(agentId, operationId),
    },
    async (commitRemoval, assertCurrent) => {
      assertCurrent();
      const mcpRemoval = await removeClawMcpServers({
        agentId,
        servers: record.mcpServers,
        options,
        assertCurrent,
      });
      assertCurrent();
      result.mcpServers = mcpRemoval.mcpServers;
      if (mcpRemoval.error) {
        return partial("mcp_cleanup_failed", mcpRemoval.error);
      }
      const cronJobs = result.cronJobs;
      for (const cron of record.cronJobs) {
        if (cron.status !== "removed" && (!cron.schedulerJobId || cron.status !== "complete")) {
          throw new ClawRemoveError(
            "cron_cleanup_uncertain",
            `Cron declaration ${JSON.stringify(cron.manifestId)} is not safely removable.`,
          );
        }
        if (
          cron.status !== "removed" &&
          (!options.cronGateway?.get || !options.cronGateway.remove)
        ) {
          throw new ClawRemoveError(
            "cron_gateway_required",
            "Claw cron jobs require the gateway-owned cron.get and cron.remove APIs.",
          );
        }
        try {
          if (cron.status !== "removed") {
            const live = await options.cronGateway!.get!(cron.schedulerJobId!);
            if (live != null && !clawCronGatewayJobMatchesRef(agentId, cron, live)) {
              throw new Error(
                `Cron declaration ${JSON.stringify(cron.manifestId)} changed after planning.`,
              );
            }
            assertCurrent();
            if (live != null) {
              try {
                await options.cronGateway!.remove(cron.schedulerJobId!);
              } catch (removeError) {
                // Re-read after transport loss; a durable removal may have succeeded.
                const afterRemove = await options.cronGateway!.get!(cron.schedulerJobId!);
                if (afterRemove != null) {
                  throw removeError;
                }
              }
            }
            assertCurrent();
            markClawCronRefRemoved(agentId, cron.manifestId, options);
          }
          deleteClawCronRef(agentId, cron.manifestId, options);
          cronJobs.push({
            manifestId: cron.manifestId,
            schedulerJobId: cron.schedulerJobId,
            action: "removed",
          });
        } catch (error) {
          const message = coerceErrorMessage(error);
          cronJobs.push({
            manifestId: cron.manifestId,
            schedulerJobId: cron.schedulerJobId,
            action: "error",
            message,
          });
          return partial("cron_cleanup_failed", message);
        }
      }
      const configRemoval = await commitRemoval();
      const { cleanupTargets, configBeforeDelete, completeDeletion } = configRemoval;
      result.agentRemoved = configRemoval.agentRemoved;
      try {
        await configRemoval.drainMonitors();
        configRemoval.assertCurrent();
      } catch (error) {
        return partial("monitor_cleanup_failed", coerceErrorMessage(error));
      }
      const purgeSessions =
        options.purgeSessions ??
        (await import("../config/sessions/cleanup-service.js")).purgeAgentSessionStoreEntries;
      const purgeFailed = await purgeSessions(configBeforeDelete, agentId, {
        env: options.env,
        runDatabaseCleanup: configRemoval.runDatabaseCleanup,
      });
      assertCurrent();
      if (purgeFailed) {
        return partial(
          "session_cleanup_failed",
          "Session cleanup failed; correct the reported error and retry Claw removal.",
        );
      }
      try {
        const removed = await applyClawPackageRemovalPhase(packageDecisions, {
          ...options,
          agentId,
          operationId: configRemoval.operationId,
          assertCurrent,
        });
        result.packages = removed.packages;
        result.pluginRuntime = removed.application;
        result.warnings = removed.warnings;
      } catch (error) {
        return partial("package_cleanup_failed", coerceErrorMessage(error));
      }
      assertCurrent();
      const packageErrors = result.packages.filter((pkg) => pkg.action === "error");
      if (packageErrors.length > 0) {
        return partial("package_cleanup_failed", packageErrors.map((pkg) => pkg.reason).join("; "));
      }
      const workspaceFiles = result.workspaceFiles;
      for (const file of record.workspaceFiles) {
        assertCurrent();
        workspaceFiles.push(await removeClawWorkspaceFile(file, assertCurrent));
      }
      assertCurrent();
      const bootstrap = await removeClawBootstrap(record, assertCurrent);
      const cleanupErrors = workspaceFiles
        .filter((file) => file.action === "error")
        .map((file) => file.message ?? `Could not remove ${file.path}.`);
      if (bootstrap?.action === "error") {
        cleanupErrors.push(bootstrap.message ?? `Could not remove ${bootstrap.path}.`);
      }
      if (cleanupErrors.length === 0) {
        const workspaceHasRemainingEntries = await workspaceContainsUntrackedEntries(
          cleanupTargets.workspaceDir,
          record.workspaceFiles.map((file) => file.path),
        );
        configRemoval.assertCurrent();
        cleanupErrors.push(
          ...(await cleanupClawAgentFilesystem({
            agentId,
            nextConfig: configRemoval.nextConfig,
            targets: cleanupTargets,
            runtime: clawRemoveQuietRuntime,
            trashPath: options.trashPath,
            stateDatabase: options,
            assertCurrent,
            retainWorkspace:
              workspaceHasRemainingEntries ||
              bootstrap?.action === "retainedModified" ||
              workspaceFiles.some((file) => file.action === "retainedModified"),
          })),
        );
      }
      const complete = releaseClawRemoveRows(
        agentId,
        workspaceFiles,
        cleanupErrors,
        configRemoval.assertCurrent,
        completeDeletion,
        options,
      );
      return {
        ...result,
        status: complete ? "complete" : "partial",
        ...(bootstrap ? { bootstrap } : {}),
        packageRefsReleased: complete ? record.packages.length : 0,
        ...(complete
          ? {}
          : {
              error: {
                code: "workspace_cleanup_failed",
                message: cleanupErrors.join("; "),
              },
            }),
      };
    },
  ).catch((error: unknown) =>
    partial(
      error instanceof ClawRemoveError ? error.code : "monitor_cleanup_failed",
      coerceErrorMessage(error),
    ),
  );
}