@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/workspace/sessions-route.js

@@ -0,0 +1,108 @@
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { deriveTranscriptDir } from "../agent/providers/claude/transport/transcript-tailer.js";
+const HEADER_READ_BYTES = 64 * 1024;
+async function readHeader(filePath) {
+    const fh = await fsp.open(filePath, "r");
+    try {
+        const buf = Buffer.alloc(HEADER_READ_BYTES);
+        const { bytesRead } = await fh.read(buf, 0, HEADER_READ_BYTES, 0);
+        if (bytesRead === 0)
+            return null;
+        const slice = buf.subarray(0, bytesRead);
+        const nlIdx = slice.indexOf(0x0a);
+        const lineEnd = nlIdx === -1 ? bytesRead : nlIdx;
+        const line = slice.subarray(0, lineEnd).toString("utf-8").trim();
+        if (line.length === 0)
+            return null;
+        const obj = JSON.parse(line);
+        return {
+            title: typeof obj["custom-title"] === "string" ? obj["custom-title"] : null,
+            cwd: typeof obj.cwd === "string" ? obj.cwd : null,
+            agentName: typeof obj.agentName === "string" ? obj.agentName : null,
+            lastActivity: typeof obj.lastActivity === "string" ? obj.lastActivity : null,
+        };
+    }
+    finally {
+        await fh.close();
+    }
+}
+async function loadSession(transcriptDir, fileName, workspaceCwd, logger) {
+    const sid = fileName.slice(0, -".jsonl".length);
+    const filePath = path.join(transcriptDir, fileName);
+    let stat;
+    try {
+        stat = await fsp.stat(filePath);
+    }
+    catch (err) {
+        logger.warn({ sid, err }, "failed to stat session file");
+        return null;
+    }
+    if (!stat.isFile())
+        return null;
+    try {
+        const header = await readHeader(filePath);
+        const lastActivity = header?.lastActivity ?? new Date(stat.mtimeMs).toISOString();
+        return {
+            sid,
+            title: header?.title ?? null,
+            lastActivity,
+            cwd: header?.cwd ?? workspaceCwd,
+            agentName: header?.agentName ?? null,
+        };
+    }
+    catch (err) {
+        logger.warn({ sid, err }, "failed to parse session header");
+        return null;
+    }
+}
+export function registerWorkspaceSessionsRoute(app, workspaceRegistry, logger) {
+    const routeLogger = logger.child({ component: "workspace-sessions-route" });
+    app.get("/workspace/:id/sessions", (req, res) => {
+        void (async () => {
+            const workspaceId = req.params.id;
+            let record;
+            try {
+                record = await workspaceRegistry.get(workspaceId);
+            }
+            catch (err) {
+                routeLogger.error({ err, workspaceId }, "workspace registry lookup failed");
+                res.status(500).json({ error: "registry_error" });
+                return;
+            }
+            if (!record) {
+                res.status(404).json({ error: "workspace_not_found" });
+                return;
+            }
+            const workspaceCwd = record.cwd;
+            const transcriptDir = deriveTranscriptDir(workspaceCwd);
+            let entries;
+            try {
+                entries = await fsp.readdir(transcriptDir);
+            }
+            catch (err) {
+                const errno = err.code;
+                if (errno === "ENOENT") {
+                    res.status(200).json({ sessions: [] });
+                    return;
+                }
+                routeLogger.error({ err, transcriptDir }, "failed to read transcript directory");
+                res.status(500).json({ error: "readdir_failed" });
+                return;
+            }
+            const jsonlFiles = entries.filter((name) => name.toLowerCase().endsWith(".jsonl"));
+            const results = await Promise.all(jsonlFiles.map((name) => loadSession(transcriptDir, name, workspaceCwd, routeLogger)));
+            const sessions = results.filter((x) => x !== null);
+            sessions.sort((a, b) => {
+                if (a.lastActivity < b.lastActivity)
+                    return 1;
+                if (a.lastActivity > b.lastActivity)
+                    return -1;
+                return 0;
+            });
+            res.status(200).json({ sessions });
+        })();
+    });
+    routeLogger.info("Registered GET /workspace/:id/sessions");
+}
+//# sourceMappingURL=sessions-route.js.map

package/dist/server/server/workspace/sessions-search-route.d.ts

@@ -0,0 +1,68 @@
+import type express from "express";
+import type pino from "pino";
+export interface SearchResultEntry {
+    sid: string;
+    source: string;
+    cwd: string;
+    timestamp: string;
+    snippet: string;
+    resumeCommand: string;
+}
+export interface SearchResultsResponse {
+    query: string;
+    results: SearchResultEntry[];
+}
+export interface SessionsSearchRouteOptions {
+    /** Override the recall binary path. Defaults to `recall` on PATH. Tests inject a fixture. */
+    recallBinaryPath?: string;
+    /** Override the spawn factory for tests. Returns stdout JSON synchronously. */
+    spawnRecall?: (args: string[]) => Promise<string>;
+    /** Subprocess timeout in ms. Defaults to 30s (recall re-indexes on every
+     * invocation; a large corpus can push cold reads past 8s). */
+    timeoutMs?: number;
+    /** Override the openable check (tests inject a fixture). Defaults to on-disk existence. */
+    isOpenable?: (entry: SearchResultEntry) => Promise<boolean>;
+}
+export declare class RecallNotInstalledError extends Error {
+    constructor();
+}
+export declare class RecallTimedOutError extends Error {
+    readonly waitedMs: number;
+    constructor(waitedMs: number);
+}
+/** Thrown when the recall subprocess emits stdout that isn't valid JSON. */
+export declare class RecallParseError extends Error {
+    constructor();
+}
+export interface RunSessionsSearchParams {
+    query: string;
+    /** Max results. Clamped to [1, 100]; defaults to 20. */
+    limit?: number;
+    /** Comma-separated source list (e.g. "paseo,claude"). Defaults to "paseo,claude". */
+    sources?: string;
+}
+export interface RunSessionsSearchDeps {
+    /** Override the spawn factory (tests inject a fixture). */
+    runRecall?: (args: string[]) => Promise<string>;
+    recallBinaryPath?: string;
+    timeoutMs?: number;
+    /**
+     * Override the openable check (tests inject a fixture). Defaults to verifying
+     * the hit's transcript/agent record still exists on disk — recall's index
+     * goes stale and returns deleted sessions.
+     */
+    isOpenable?: (entry: SearchResultEntry) => Promise<boolean>;
+}
+/**
+ * Core recall FTS — spawns the `recall` CLI and returns parsed results. Shared
+ * by the HTTP `GET /sessions/search` route AND the `search_sessions_request`
+ * WS handler (so the command palette works over the relay).
+ *
+ * Sub-`MIN_QUERY_LEN` queries return `{ results: [] }` WITHOUT spawning.
+ * Throws `RecallNotInstalledError` / `RecallTimedOutError` / `RecallParseError`
+ * (or a generic Error) on failure — callers map these to transport-specific
+ * error codes.
+ */
+export declare function runSessionsSearch(params: RunSessionsSearchParams, logger: pino.Logger, deps?: RunSessionsSearchDeps): Promise<SearchResultsResponse>;
+export declare function registerSessionsSearchRoute(app: express.Express, logger: pino.Logger, options?: SessionsSearchRouteOptions): void;
+//# sourceMappingURL=sessions-search-route.d.ts.map

package/dist/server/server/workspace/sessions-search-route.js

@@ -0,0 +1,203 @@
+import { spawn } from "node:child_process";
+import { isSessionOpenable } from "./session-openable.js";
+const DEFAULT_TIMEOUT_MS = 30000;
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 20;
+const MIN_QUERY_LEN = 2;
+const DEFAULT_SOURCES = "paseo,claude";
+export class RecallNotInstalledError extends Error {
+    constructor() {
+        super("recall binary not found on PATH");
+        this.name = "RecallNotInstalledError";
+    }
+}
+export class RecallTimedOutError extends Error {
+    constructor(waitedMs) {
+        super(`recall subprocess timed out after ${waitedMs}ms`);
+        this.waitedMs = waitedMs;
+        this.name = "RecallTimedOutError";
+    }
+}
+/** Thrown when the recall subprocess emits stdout that isn't valid JSON. */
+export class RecallParseError extends Error {
+    constructor() {
+        super("recall_parse_failed");
+        this.name = "RecallParseError";
+    }
+}
+function spawnRecallDefault(binaryPath, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binaryPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new RecallTimedOutError(timeoutMs));
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf-8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf-8");
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            if (err.code === "ENOENT") {
+                reject(new RecallNotInstalledError());
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(`recall exited with code ${code}: ${stderr.trim()}`));
+            }
+        });
+    });
+}
+// recall (re)builds its Tantivy index on each invocation and takes a writer
+// lock. The command palette debounce fires a search per keystroke, so without
+// serialization concurrent recall processes collide on the lock:
+//   "Failed to acquire Lockfile: LockBusy — Failed to acquire index lock"
+// → the search returns nothing and the palette looks broken. Serialize all
+// recall spawns within this daemon process to one-at-a-time, and retry once on
+// a lock-busy error (covers a stale lock from a killed process too).
+const serializeRecall = (() => {
+    let chain = Promise.resolve();
+    return (fn) => {
+        const run = chain.then(fn, fn);
+        chain = run.then(() => undefined, () => undefined);
+        return run;
+    };
+})();
+function isRecallLockBusy(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return (message.includes("LockBusy") ||
+        message.includes("acquire index lock") ||
+        message.includes("Failed to acquire"));
+}
+function spawnRecallSerialized(binaryPath, args, timeoutMs) {
+    return serializeRecall(async () => {
+        try {
+            return await spawnRecallDefault(binaryPath, args, timeoutMs);
+        }
+        catch (error) {
+            if (isRecallLockBusy(error)) {
+                await new Promise((resolve) => setTimeout(resolve, 200));
+                return await spawnRecallDefault(binaryPath, args, timeoutMs);
+            }
+            throw error;
+        }
+    });
+}
+function buildSnippet(messages) {
+    const first = messages[0];
+    if (!first)
+        return "";
+    const collapsed = first.content.replace(/\s+/g, " ").trim();
+    return collapsed.length > 220 ? `${collapsed.slice(0, 220)}…` : collapsed;
+}
+function toEntry(raw) {
+    return {
+        sid: raw.session_id,
+        source: raw.source,
+        cwd: raw.cwd,
+        timestamp: raw.timestamp,
+        snippet: buildSnippet(raw.relevant_messages ?? []),
+        resumeCommand: raw.resume_command,
+    };
+}
+/**
+ * Core recall FTS — spawns the `recall` CLI and returns parsed results. Shared
+ * by the HTTP `GET /sessions/search` route AND the `search_sessions_request`
+ * WS handler (so the command palette works over the relay).
+ *
+ * Sub-`MIN_QUERY_LEN` queries return `{ results: [] }` WITHOUT spawning.
+ * Throws `RecallNotInstalledError` / `RecallTimedOutError` / `RecallParseError`
+ * (or a generic Error) on failure — callers map these to transport-specific
+ * error codes.
+ */
+export async function runSessionsSearch(params, logger, deps = {}) {
+    const query = (params.query ?? "").trim();
+    if (query.length < MIN_QUERY_LEN) {
+        return { query, results: [] };
+    }
+    const rawLimit = params.limit;
+    const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0
+        ? Math.min(rawLimit, MAX_LIMIT)
+        : DEFAULT_LIMIT;
+    const sources = params.sources && params.sources.length > 0 ? params.sources : DEFAULT_SOURCES;
+    const binaryPath = deps.recallBinaryPath ?? "recall";
+    const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const runRecall = deps.runRecall ?? ((args) => spawnRecallSerialized(binaryPath, args, timeoutMs));
+    const args = ["search", query, "--source", sources, "--limit", String(limit)];
+    const stdout = await runRecall(args);
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        logger.error({ err, stdout: stdout.slice(0, 200) }, "failed to parse recall stdout");
+        throw new RecallParseError();
+    }
+    const mapped = Array.isArray(parsed.results)
+        ? parsed.results.map(toEntry)
+        : [];
+    // Drop hits whose underlying source no longer exists on disk (recall's index
+    // goes stale). Without this the palette offers sessions that fail to open.
+    const isOpenable = deps.isOpenable ?? ((entry) => isSessionOpenable(entry));
+    const openableFlags = await Promise.all(mapped.map((entry) => isOpenable(entry)));
+    const results = mapped.filter((_, index) => openableFlags[index]);
+    const dropped = mapped.length - results.length;
+    if (dropped > 0) {
+        logger.debug({ dropped, kept: results.length }, "filtered unopenable recall hits");
+    }
+    return { query: parsed.query ?? query, results };
+}
+export function registerSessionsSearchRoute(app, logger, options = {}) {
+    const routeLogger = logger.child({ component: "sessions-search-route" });
+    const binaryPath = options.recallBinaryPath ?? "recall";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const runRecall = options.spawnRecall ?? ((args) => spawnRecallSerialized(binaryPath, args, timeoutMs));
+    app.get("/sessions/search", (req, res) => {
+        void (async () => {
+            const query = typeof req.query.q === "string" ? req.query.q.trim() : "";
+            const rawLimit = typeof req.query.limit === "string" ? Number.parseInt(req.query.limit, 10) : undefined;
+            const sources = typeof req.query.source === "string" && req.query.source.length > 0
+                ? req.query.source
+                : undefined;
+            try {
+                const out = await runSessionsSearch({ query, limit: rawLimit, sources }, routeLogger, {
+                    runRecall,
+                    ...(options.isOpenable ? { isOpenable: options.isOpenable } : {}),
+                });
+                res.status(200).json(out);
+            }
+            catch (err) {
+                if (err instanceof RecallNotInstalledError) {
+                    routeLogger.warn({ binaryPath }, "recall binary not installed on PATH");
+                    res.status(503).json({ error: "recall_not_installed" });
+                    return;
+                }
+                if (err instanceof RecallTimedOutError) {
+                    routeLogger.warn({ waitedMs: err.waitedMs, query }, "recall subprocess timed out");
+                    res.status(504).json({ error: "recall_timeout" });
+                    return;
+                }
+                if (err instanceof RecallParseError) {
+                    res.status(500).json({ error: "recall_parse_failed" });
+                    return;
+                }
+                routeLogger.error({ err, query }, "recall subprocess failed");
+                res.status(500).json({ error: "recall_failed" });
+            }
+        })();
+    });
+    routeLogger.info({ binaryPath, timeoutMs }, "Registered GET /sessions/search");
+}
+//# sourceMappingURL=sessions-search-route.js.map

package/dist/server/server/workspace-archive-service.d.ts

@@ -0,0 +1,65 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { GitHubService } from "../services/github-service.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type { PersistedWorkspaceRecord, WorkspaceRegistry } from "./workspace-registry.js";
+export interface ActiveWorkspaceRef {
+    workspaceId: string;
+    cwd: string;
+    kind?: "local_checkout" | "worktree" | "directory";
+}
+export interface ArchiveDependencies {
+    paseoHome?: string;
+    paseoWorktreesBaseRoot?: string;
+    github: GitHubService;
+    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot">;
+    agentManager: Pick<AgentManager, "listAgents" | "archiveAgent" | "archiveSnapshot">;
+    agentStorage: Pick<AgentStorage, "list">;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
+    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
+    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
+    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
+    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
+    killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
+    sessionLogger?: Logger;
+}
+export interface KillTerminalsForWorkspaceDependencies {
+    detachTerminalStream?: (terminalId: string, options: {
+        emitExit: boolean;
+    }) => void;
+    sessionLogger: Logger;
+    terminalManager: TerminalManager | null;
+}
+export type ArchiveScope = {
+    kind: "workspace";
+    workspaceId: string;
+} | {
+    kind: "worktree";
+    targetPath: string;
+};
+export interface ArchiveResult {
+    archivedAgentIds: string[];
+    archivedWorkspaceIds: string[];
+    removedDirectory: boolean;
+}
+export interface ArchiveByScopeRequest {
+    scope: ArchiveScope;
+    repoRoot: string | null;
+    repoWorktreesRoot?: string;
+    paseoWorktreesBaseRoot?: string;
+    requestId: string;
+}
+export declare function resolveWorkspaceIdAtPath(dependencies: Pick<ArchiveDependencies, "findWorkspaceIdForCwd" | "listActiveWorkspaces">, targetPath: string): Promise<string | null>;
+export declare function archiveByScope(dependencies: ArchiveDependencies, request: ArchiveByScopeRequest): Promise<ArchiveResult>;
+export type ArchiveWorkspaceContentsDependencies = Pick<ArchiveDependencies, "agentManager" | "agentStorage" | "killTerminalsForWorkspace" | "sessionLogger">;
+export declare function archiveWorkspaceContents(dependencies: ArchiveWorkspaceContentsDependencies, workspaceId: string): Promise<Set<string>>;
+export declare function killTerminalsForWorkspace(dependencies: KillTerminalsForWorkspaceDependencies, workspaceId: string): Promise<void>;
+export declare function archivePersistedWorkspaceRecord(input: {
+    workspaceId: string;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get" | "archive">;
+    archivedAt?: string;
+}): Promise<PersistedWorkspaceRecord | null>;
+//# sourceMappingURL=workspace-archive-service.d.ts.map

package/dist/server/server/workspace-archive-service.js

@@ -0,0 +1,229 @@
+import { resolve } from "node:path";
+import { deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, WorktreeTeardownError, } from "../utils/worktree.js";
+export async function resolveWorkspaceIdAtPath(dependencies, targetPath) {
+    const targetDir = resolve(targetPath);
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    const exactMatches = activeWorkspaces.filter((workspace) => resolve(workspace.cwd) === targetDir);
+    const worktreeMatch = exactMatches.find((workspace) => workspace.kind === "worktree");
+    if (worktreeMatch) {
+        return worktreeMatch.workspaceId;
+    }
+    return dependencies.findWorkspaceIdForCwd(targetPath);
+}
+// THE single archive entry. Resolves the in-scope record set, tears each down
+// (agents + terminals + record), then removes the backing directory iff it is
+// Paseo-owned AND no active workspace still references it.
+export async function archiveByScope(dependencies, request) {
+    const { targetDir, targetWorkspaceIds } = await resolveArchiveTargets(dependencies, request.scope, request.paseoWorktreesBaseRoot);
+    if (targetWorkspaceIds.length > 0) {
+        dependencies.markWorkspaceArchiving(targetWorkspaceIds, new Date().toISOString());
+    }
+    let removedDirectory = false;
+    try {
+        if (targetWorkspaceIds.length > 0) {
+            await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
+        }
+        const { archivedAgents, archivedWorkspaceIds } = await archiveTargetRecords(dependencies, targetWorkspaceIds, request.requestId);
+        if (request.repoRoot) {
+            try {
+                await dependencies.workspaceGitService.getSnapshot(request.repoRoot, {
+                    force: true,
+                    reason: "archive-worktree",
+                });
+            }
+            catch (error) {
+                dependencies.sessionLogger?.warn({ err: error, cwd: request.repoRoot, requestId: request.requestId }, "Failed to force-refresh workspace git snapshot after archiving");
+            }
+        }
+        if (targetDir !== null) {
+            removedDirectory = await maybeRemoveDirectory(dependencies, request, targetDir, archivedWorkspaceIds);
+        }
+        return {
+            archivedAgentIds: Array.from(archivedAgents),
+            archivedWorkspaceIds,
+            removedDirectory,
+        };
+    }
+    finally {
+        if (targetWorkspaceIds.length > 0) {
+            dependencies.clearWorkspaceArchiving(targetWorkspaceIds);
+            await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
+        }
+    }
+}
+async function resolveArchiveTargets(dependencies, scope, paseoWorktreesBaseRoot) {
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    if (scope.kind === "workspace") {
+        const workspaceId = scope.workspaceId;
+        const record = activeWorkspaces.find((workspace) => workspace.workspaceId === workspaceId);
+        if (!record) {
+            dependencies.sessionLogger?.warn({ workspaceId }, "Workspace not found for archive-by-scope; skipping");
+            return { targetDir: null, targetWorkspaceIds: [] };
+        }
+        return { targetDir: resolve(record.cwd), targetWorkspaceIds: [workspaceId] };
+    }
+    let targetPath = scope.targetPath;
+    const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
+        paseoHome: dependencies.paseoHome,
+        worktreesRoot: paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+    });
+    if (resolvedWorktree) {
+        targetPath = resolvedWorktree.worktreePath;
+    }
+    const targetDir = resolve(targetPath);
+    const targetWorkspaceIds = activeWorkspaces
+        .filter((workspace) => resolve(workspace.cwd) === targetDir)
+        .map((workspace) => workspace.workspaceId);
+    return { targetDir, targetWorkspaceIds };
+}
+async function archiveTargetRecords(dependencies, targetWorkspaceIds, requestId) {
+    const archivedAgents = new Set();
+    const archivedWorkspaceIds = [];
+    const results = await Promise.allSettled(targetWorkspaceIds.map(async (workspaceId) => {
+        const agents = await archiveWorkspaceContents(dependencies, workspaceId);
+        await dependencies.archiveWorkspaceRecord(workspaceId);
+        return { workspaceId, agents };
+    }));
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            archivedWorkspaceIds.push(result.value.workspaceId);
+            for (const agentId of result.value.agents) {
+                archivedAgents.add(agentId);
+            }
+        }
+        else {
+            dependencies.sessionLogger?.warn({ err: result.reason, requestId }, "archiveByScope workspace teardown failed; continuing");
+        }
+    }
+    return { archivedAgents, archivedWorkspaceIds };
+}
+async function maybeRemoveDirectory(dependencies, request, targetDir, archivedWorkspaceIds) {
+    const ownership = await isPaseoOwnedWorktreeCwd(targetDir, {
+        paseoHome: dependencies.paseoHome,
+        worktreesRoot: request.paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+    });
+    if (!ownership.allowed) {
+        return false;
+    }
+    const remainingActive = await dependencies.listActiveWorkspaces();
+    if (!isDirectoryUnreferenced(remainingActive, targetDir, new Set(archivedWorkspaceIds))) {
+        return false;
+    }
+    try {
+        await deletePaseoWorktree({
+            cwd: request.repoRoot,
+            worktreePath: targetDir,
+            worktreesRoot: request.repoWorktreesRoot ?? ownership.worktreeRoot,
+            paseoHome: dependencies.paseoHome,
+            worktreesBaseRoot: request.paseoWorktreesBaseRoot ?? dependencies.paseoWorktreesBaseRoot,
+        });
+        dependencies.github.invalidate({ cwd: targetDir });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof WorktreeTeardownError) {
+            dependencies.sessionLogger?.warn({ err: error, targetPath: targetDir, requestId: request.requestId }, "Worktree disk removal failed during archive; workspace already archived");
+            return false;
+        }
+        throw error;
+    }
+}
+// Tears down everything OWNED by a single workspace record: its live agents,
+// its persisted-but-not-running agent snapshots, and its terminals. Scoped by
+// workspaceId so a sibling workspace sharing the same directory is untouched.
+// Returns the set of archived agent ids.
+export async function archiveWorkspaceContents(dependencies, workspaceId) {
+    const archivedAgents = new Set();
+    const liveAgents = dependencies.agentManager
+        .listAgents()
+        .filter((agent) => agent.workspaceId === workspaceId);
+    for (const agent of liveAgents) {
+        archivedAgents.add(agent.id);
+    }
+    let storedRecords = [];
+    try {
+        storedRecords = await dependencies.agentStorage.list();
+    }
+    catch (error) {
+        dependencies.sessionLogger?.warn({ err: error, workspaceId }, "Failed to list stored agents during workspace archive; continuing");
+    }
+    const liveAgentIds = new Set(liveAgents.map((agent) => agent.id));
+    const matchingStoredRecords = storedRecords.filter((record) => record.workspaceId === workspaceId);
+    for (const record of matchingStoredRecords) {
+        archivedAgents.add(record.id);
+    }
+    const archivedAt = new Date().toISOString();
+    const archiveResults = await Promise.allSettled([
+        ...liveAgents.map((agent) => dependencies.agentManager.archiveAgent(agent.id)),
+        ...matchingStoredRecords
+            .filter((record) => !liveAgentIds.has(record.id) && !record.archivedAt)
+            .map((record) => dependencies.agentManager.archiveSnapshot(record.id, archivedAt)),
+        dependencies.killTerminalsForWorkspace(workspaceId),
+    ]);
+    for (const result of archiveResults) {
+        if (result.status === "rejected") {
+            dependencies.sessionLogger?.warn({ err: result.reason, workspaceId }, "Workspace archive teardown step failed; continuing");
+        }
+    }
+    return archivedAgents;
+}
+// EXACTLY one last-reference predicate in the module. True when, after archiving
+// the in-scope records, no active workspace still points at targetDir. Derived
+// from records each call — no stored counter.
+function isDirectoryUnreferenced(activeWorkspaces, targetDir, archivedWorkspaceIds) {
+    const target = resolve(targetDir);
+    return !activeWorkspaces.some((workspace) => !archivedWorkspaceIds.has(workspace.workspaceId) && resolve(workspace.cwd) === target);
+}
+export async function killTerminalsForWorkspace(dependencies, workspaceId) {
+    const terminalManager = dependencies.terminalManager;
+    if (!terminalManager) {
+        return;
+    }
+    const terminalIds = [];
+    const terminalLists = await Promise.all(terminalManager.listDirectories().map(async (terminalCwd) => {
+        try {
+            return await terminalManager.getTerminals(terminalCwd, { workspaceId });
+        }
+        catch (error) {
+            dependencies.sessionLogger.warn({ err: error, cwd: terminalCwd }, "Failed to enumerate workspace terminals during archive");
+            return [];
+        }
+    }));
+    for (const terminals of terminalLists) {
+        for (const terminal of terminals) {
+            if (terminal.workspaceId === workspaceId) {
+                terminalIds.push(terminal.id);
+            }
+        }
+    }
+    if (terminalIds.length === 0) {
+        return;
+    }
+    await Promise.allSettled(terminalIds.map(async (terminalId) => {
+        try {
+            dependencies.detachTerminalStream?.(terminalId, { emitExit: true });
+            await terminalManager.killTerminalAndWait(terminalId, {
+                gracefulTimeoutMs: 2000,
+                forceTimeoutMs: 1500,
+            });
+        }
+        catch (error) {
+            dependencies.sessionLogger.warn({ err: error, terminalId }, "Terminal kill escalation failed during archive; proceeding anyway");
+        }
+    }));
+}
+// Archiving the last workspace of a project leaves the project record active.
+// The user removes the project explicitly, so we never archive the parent here.
+export async function archivePersistedWorkspaceRecord(input) {
+    const existingWorkspace = await input.workspaceRegistry.get(input.workspaceId);
+    if (!existingWorkspace) {
+        return null;
+    }
+    if (existingWorkspace.archivedAt) {
+        return existingWorkspace;
+    }
+    const archivedAt = input.archivedAt ?? new Date().toISOString();
+    await input.workspaceRegistry.archive(input.workspaceId, archivedAt);
+    return existingWorkspace;
+}
+//# sourceMappingURL=workspace-archive-service.js.map