Method archive

src/node/services/workspaceService.ts:5393–5624

* Archive a workspace. Archived workspaces are hidden from the main sidebar * but can be viewed on the project page. * * If init is still running, we abort it before archiving so we don't leave * orphaned post-create work running in the background. * * Returns a typed confirmation

(
    workspaceId: string,
    acknowledgedUntrackedPaths?: string[]
  )

   * untracked-file set must be re-reviewed before a lossy snapshot archive can proceed.
   */
  async archive(
    workspaceId: string,
    acknowledgedUntrackedPaths?: string[]
  ): Promise<Result<ArchiveWorkspaceResult>> {
    this.archivingWorkspaces.add(workspaceId);

    try {
      const workspace = this.config.findWorkspace(workspaceId);
      if (!workspace) {
        return Err("Workspace not found");
      }
      const initState = this.initStateManager.getInitState(workspaceId);
      if (initState?.status === "running") {
        // Archiving should not leave post-create setup running in the background.
        const initAbortController = this.initAbortControllers.get(workspaceId);
        if (initAbortController) {
          initAbortController.abort();
          this.initAbortControllers.delete(workspaceId);
        }

        this.initStateManager.clearInMemoryState(workspaceId);

        // Clearing init state prevents init-end from firing (createInitLogger.logComplete() bails when
        // state is missing). If archiving fails before we persist archivedAt (e.g., beforeArchive hook
        // error), ensure the sidebar doesn't stay stuck on isInitializing/"Cancel creation".
        try {
          const allMetadata = await this.config.getAllWorkspaceMetadata();
          const updatedMetadata = allMetadata.find((m) => m.id === workspaceId);
          if (updatedMetadata) {
            const enrichedMetadata = this.enrichFrontendMetadata(updatedMetadata);
            const session = this.sessions.get(workspaceId);
            if (session) {
              session.emitMetadata(enrichedMetadata);
            } else {
              this.emit("metadata", { workspaceId, metadata: enrichedMetadata });
            }
          }
        } catch (error) {
          log.debug("Failed to emit metadata after init cancellation during archive", {
            workspaceId,
            error: getErrorMessage(error),
          });
        }
      }

      const { projectPath, workspacePath } = workspace;
      const worktreeArchiveBehavior = this.getWorktreeArchiveBehavior();
      const snapshotBehaviorEnabled =
        worktreeArchiveBehavior === "snapshot" && this.worktreeArchiveSnapshotService != null;

      let beforeArchiveMetadata: WorkspaceMetadata | undefined;
      if (this.workspaceLifecycleHooks || snapshotBehaviorEnabled) {
        const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
        if (!metadataResult.success) {
          return Err(metadataResult.error);
        }
        beforeArchiveMetadata = metadataResult.data;
      }