@getpaseo/server 0.1.96 → 0.1.97-beta.2

package/dist/server/server/loop-service.d.ts

@@ -34,17 +34,17 @@ declare const LoopVerifyCheckResultSchema: z.ZodObject<{
     startedAt: z.ZodString;
     completedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    stdout: string;
     exitCode: number;
     command: string;
-    stdout: string;
     stderr: string;
     startedAt: string;
     completedAt: string;
     passed: boolean;
 }, {
+    stdout: string;
     exitCode: number;
     command: string;
-    stdout: string;
     stderr: string;
     startedAt: string;
     completedAt: string;
@@ -57,15 +57,15 @@ declare const LoopVerifyPromptResultSchema: z.ZodObject<{
     startedAt: z.ZodString;
     completedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    reason: string;
     startedAt: string;
     completedAt: string;
+    reason: string;
     passed: boolean;
     verifierAgentId: string | null;
 }, {
-    reason: string;
     startedAt: string;
     completedAt: string;
+    reason: string;
     passed: boolean;
     verifierAgentId: string | null;
 }>;
@@ -87,17 +87,17 @@ declare const LoopIterationRecordSchema: z.ZodObject<{
         startedAt: z.ZodString;
         completedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
+        stdout: string;
         exitCode: number;
         command: string;
-        stdout: string;
         stderr: string;
         startedAt: string;
         completedAt: string;
         passed: boolean;
     }, {
+        stdout: string;
         exitCode: number;
         command: string;
-        stdout: string;
         stderr: string;
         startedAt: string;
         completedAt: string;
@@ -110,15 +110,15 @@ declare const LoopIterationRecordSchema: z.ZodObject<{
         startedAt: z.ZodString;
         completedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        reason: string;
         startedAt: string;
         completedAt: string;
+        reason: string;
         passed: boolean;
         verifierAgentId: string | null;
     }, {
-        reason: string;
         startedAt: string;
         completedAt: string;
+        reason: string;
         passed: boolean;
         verifierAgentId: string | null;
     }>>;
@@ -132,18 +132,18 @@ declare const LoopIterationRecordSchema: z.ZodObject<{
     workerOutcome: "completed" | "failed" | "canceled" | null;
     failureReason: string | null;
     verifyChecks: {
+        stdout: string;
         exitCode: number;
         command: string;
-        stdout: string;
         stderr: string;
         startedAt: string;
         completedAt: string;
         passed: boolean;
     }[];
     verifyPrompt: {
-        reason: string;
         startedAt: string;
         completedAt: string;
+        reason: string;
         passed: boolean;
         verifierAgentId: string | null;
     } | null;
@@ -157,18 +157,18 @@ declare const LoopIterationRecordSchema: z.ZodObject<{
     workerOutcome: "completed" | "failed" | "canceled" | null;
     failureReason: string | null;
     verifyChecks: {
+        stdout: string;
         exitCode: number;
         command: string;
-        stdout: string;
         stderr: string;
         startedAt: string;
         completedAt: string;
         passed: boolean;
     }[];
     verifyPrompt: {
-        reason: string;
         startedAt: string;
         completedAt: string;
+        reason: string;
         passed: boolean;
         verifierAgentId: string | null;
     } | null;
@@ -216,17 +216,17 @@ declare const LoopRecordSchema: z.ZodObject<{
             startedAt: z.ZodString;
             completedAt: z.ZodString;
         }, "strip", z.ZodTypeAny, {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
             passed: boolean;
         }, {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
@@ -239,15 +239,15 @@ declare const LoopRecordSchema: z.ZodObject<{
             startedAt: z.ZodString;
             completedAt: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         }, {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         }>>;
@@ -261,18 +261,18 @@ declare const LoopRecordSchema: z.ZodObject<{
         workerOutcome: "completed" | "failed" | "canceled" | null;
         failureReason: string | null;
         verifyChecks: {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
             passed: boolean;
         }[];
         verifyPrompt: {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         } | null;
@@ -286,18 +286,18 @@ declare const LoopRecordSchema: z.ZodObject<{
         workerOutcome: "completed" | "failed" | "canceled" | null;
         failureReason: string | null;
         verifyChecks: {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
             passed: boolean;
         }[];
         verifyPrompt: {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         } | null;
@@ -351,18 +351,18 @@ declare const LoopRecordSchema: z.ZodObject<{
         workerOutcome: "completed" | "failed" | "canceled" | null;
         failureReason: string | null;
         verifyChecks: {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
             passed: boolean;
         }[];
         verifyPrompt: {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         } | null;
@@ -413,18 +413,18 @@ declare const LoopRecordSchema: z.ZodObject<{
         workerOutcome: "completed" | "failed" | "canceled" | null;
         failureReason: string | null;
         verifyChecks: {
+            stdout: string;
             exitCode: number;
             command: string;
-            stdout: string;
             stderr: string;
             startedAt: string;
             completedAt: string;
             passed: boolean;
         }[];
         verifyPrompt: {
-            reason: string;
             startedAt: string;
             completedAt: string;
+            reason: string;
             passed: boolean;
             verifierAgentId: string | null;
         } | null;

package/dist/server/server/migrations/backfill-workspace-id.migration.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from "pino";
+import type { AgentStorage } from "../agent/agent-storage.js";
+import type { WorkspaceRegistry } from "../workspace-registry.js";
+export declare function backfillWorkspaceIdForLegacyAgents(options: {
+    agentStorage: AgentStorage;
+    workspaceRegistry: WorkspaceRegistry;
+    logger: Logger;
+}): Promise<number>;
+//# sourceMappingURL=backfill-workspace-id.migration.d.ts.map

package/dist/server/server/migrations/backfill-workspace-id.migration.js

@@ -0,0 +1,60 @@
+// COMPAT(workspaceIdBackfill): one-time legacy backfill, delete after 2026-12-16
+// once floor >= the release that always stamps workspaceId at create time.
+//
+// This is the ONLY place in the codebase that maps a cwd to a workspaceId.
+// Every other code path treats a record's `workspaceId` field as authoritative
+// ownership. Legacy agent records persisted before workspaceId stamping have no
+// owner, so this migration stamps each one with the workspace that owned its
+// directory at the time it was written. It runs once at startup and writes the
+// id back to storage, after which all runtime code can assume the field exists.
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// Picks the workspace that owned `cwd` for a legacy, unstamped agent record.
+// Prefers an exact-cwd workspace (oldest wins) and otherwise attributes to the
+// deepest enclosing workspace directory, never letting the home directory own
+// descendants. Used only by the one-time backfill below.
+function resolveLegacyWorkspaceOwner(cwd, workspaces) {
+    const normalizedCwd = resolve(cwd);
+    const userHome = resolve(homedir());
+    const activeWorkspaces = Array.from(workspaces).filter((workspace) => !workspace.archivedAt);
+    const exactMatches = activeWorkspaces.filter((workspace) => resolve(workspace.cwd) === normalizedCwd);
+    if (exactMatches.length > 0) {
+        return oldestWorkspace(exactMatches).workspaceId;
+    }
+    const prefixMatches = activeWorkspaces.filter((workspace) => {
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome) {
+            return false;
+        }
+        return normalizedCwd === workspaceCwd || normalizedCwd.startsWith(`${workspaceCwd}${sep}`);
+    });
+    if (prefixMatches.length === 0) {
+        return null;
+    }
+    const deepestPrefixLength = Math.max(...prefixMatches.map((workspace) => resolve(workspace.cwd).length));
+    return oldestWorkspace(prefixMatches.filter((workspace) => resolve(workspace.cwd).length === deepestPrefixLength)).workspaceId;
+}
+function oldestWorkspace(workspaces) {
+    return workspaces.reduce((oldest, candidate) => candidate.createdAt < oldest.createdAt ? candidate : oldest);
+}
+export async function backfillWorkspaceIdForLegacyAgents(options) {
+    const workspaceRecords = await options.workspaceRegistry.list();
+    const records = await options.agentStorage.list();
+    let migrated = 0;
+    for (const record of records) {
+        if (record.workspaceId) {
+            continue;
+        }
+        const workspaceId = resolveLegacyWorkspaceOwner(record.cwd, workspaceRecords);
+        if (!workspaceId) {
+            continue;
+        }
+        await options.agentStorage.upsert({ ...record, workspaceId });
+        migrated += 1;
+    }
+    if (migrated > 0) {
+        options.logger.info({ migrated }, "Backfilled workspaceId for legacy agent records");
+    }
+    return migrated;
+}
+//# sourceMappingURL=backfill-workspace-id.migration.js.map

package/dist/server/server/paseo-worktree-service.d.ts

@@ -40,4 +40,13 @@ export declare function attemptFirstAgentBranchAutoName(options: {
     renameCurrentBranch?: typeof renameCurrentBranch;
     localBranchExists?: typeof localBranchExists;
 }): Promise<AttemptFirstAgentBranchAutoNameResult>;
+export interface CreateLocalCheckoutWorkspaceDeps {
+    projectRegistry: Pick<ProjectRegistry, "get" | "list" | "upsert">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "list" | "upsert">;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout">;
+}
+export declare function createLocalCheckoutWorkspace(options: {
+    cwd: string;
+    title?: string | null;
+}, deps: CreateLocalCheckoutWorkspaceDeps): Promise<PersistedWorkspaceRecord>;
 //# sourceMappingURL=paseo-worktree-service.d.ts.map

package/dist/server/server/paseo-worktree-service.js

@@ -1,9 +1,11 @@
+import { resolve } from "node:path";
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
-import { deriveProjectGroupingName, normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { classifyDirectoryForProjectMembership, deriveProjectGroupingName, generateWorkspaceId, } from "./workspace-registry-model.js";
 import { createWorktreeCore, } from "./worktree-core.js";
 import { validateBranchSlug } from "../utils/worktree.js";
 import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
 import { markPaseoWorktreeFirstAgentBranchAutoNameAttempted, readPaseoWorktreeMetadata, writePaseoWorktreeFirstAgentBranchAutoNameMetadata, } from "../utils/worktree-metadata.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
 import { buildAgentBranchNameSeed } from "./agent/prompt-attachments.js";
 export async function createPaseoWorktree(input, deps) {
     const createdWorktree = await createWorktreeCore(input, deps);
@@ -13,6 +15,7 @@ export async function createPaseoWorktree(input, deps) {
         projectId: input.projectId,
         repoRoot: createdWorktree.repoRoot,
         worktree: createdWorktree.worktree,
+        title: resolveFirstAgentPromptTitle(input.firstAgentContext),
         deps,
     });
     deps.github.invalidate({ cwd: createdWorktree.worktree.worktreePath });
@@ -107,18 +110,20 @@ function maybeMarkFirstAgentBranchAutoNameEligible(options) {
     });
 }
 async function upsertWorkspaceForWorktree(options) {
-    const normalizedCwd = normalizeWorkspaceId(options.worktree.worktreePath);
-    const normalizedInputCwd = normalizeWorkspaceId(options.inputCwd);
-    const normalizedRepoRoot = normalizeWorkspaceId(options.repoRoot);
-    const existingWorkspace = await findWorkspaceByDirectory(normalizedCwd, options.deps.workspaceRegistry);
+    const normalizedCwd = resolve(options.worktree.worktreePath);
+    const normalizedInputCwd = resolve(options.inputCwd);
+    const normalizedRepoRoot = resolve(options.repoRoot);
+    // Creation never deduplicates by directory: a worktree directory may back
+    // more than one workspace. We still resolve the source project from the
+    // originating checkout, but always mint a fresh workspace record.
     const sourceProject = await resolveSourceProjectForWorktree({
         inputCwd: normalizedInputCwd,
         projectId: options.projectId,
         repoRoot: normalizedRepoRoot,
-        existingWorkspace,
+        existingWorkspace: null,
         deps: options.deps,
     });
-    const workspaceId = normalizedCwd;
+    const workspaceId = generateWorkspaceId();
     const now = new Date().toISOString();
     await options.deps.projectRegistry.upsert(createPersistedProjectRecord({
         projectId: sourceProject.projectId,
@@ -136,13 +141,74 @@ async function upsertWorkspaceForWorktree(options) {
         cwd: normalizedCwd,
         kind: "worktree",
         displayName: options.worktree.branchName || normalizedCwd,
-        createdAt: existingWorkspace?.createdAt ?? now,
+        branch: options.worktree.branchName || null,
+        title: options.title ?? null,
+        createdAt: now,
         updatedAt: now,
         archivedAt: null,
     });
     await options.deps.workspaceRegistry.upsert(workspace);
     return (await options.deps.workspaceRegistry.get(workspace.workspaceId)) ?? workspace;
 }
+// Always create a NEW workspace record backed by the existing directory `cwd`.
+// Never reuses a same-cwd record: a directory may back any number of
+// workspaces. Used by explicit user creation.
+export async function createLocalCheckoutWorkspace(options, deps) {
+    const normalizedCwd = resolve(options.cwd);
+    const checkout = await deps.workspaceGitService.getCheckout(normalizedCwd);
+    const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+    const now = new Date().toISOString();
+    const projectRecord = await resolveProjectRecordForMembership({
+        membership,
+        timestamp: now,
+        projectRegistry: deps.projectRegistry,
+    });
+    await deps.projectRegistry.upsert(projectRecord);
+    const trimmedTitle = options.title?.trim();
+    // Persist the live git branch into the dedicated `branch` field so
+    // buildWorkspaceCheckout reports the real branch for directory/local_checkout
+    // workspaces too (it reads workspace.branch). Same source deriveWorkspaceDisplayName
+    // reads. HEAD/detached resolves to null — there is no branch to report.
+    const currentBranch = checkout.currentBranch?.trim() ?? null;
+    const branch = currentBranch && currentBranch.toUpperCase() !== "HEAD" ? currentBranch : null;
+    const workspace = createPersistedWorkspaceRecord({
+        workspaceId: generateWorkspaceId(),
+        projectId: projectRecord.projectId,
+        cwd: normalizedCwd,
+        kind: membership.workspaceKind,
+        displayName: membership.workspaceDisplayName,
+        branch,
+        title: trimmedTitle ? trimmedTitle : null,
+        createdAt: now,
+        updatedAt: now,
+    });
+    await deps.workspaceRegistry.upsert(workspace);
+    return workspace;
+}
+async function resolveProjectRecordForMembership(options) {
+    const rootPath = options.membership.projectRootPath;
+    const projects = await options.projectRegistry.list();
+    const existingProject = projects.find((project) => !project.archivedAt && project.rootPath === rootPath) ??
+        projects.find((project) => project.rootPath === rootPath) ??
+        null;
+    if (!existingProject) {
+        return createPersistedProjectRecord({
+            projectId: options.membership.projectKey,
+            rootPath,
+            kind: options.membership.projectKind,
+            displayName: options.membership.projectName,
+            createdAt: options.timestamp,
+            updatedAt: options.timestamp,
+        });
+    }
+    return {
+        ...existingProject,
+        rootPath,
+        kind: options.membership.projectKind,
+        archivedAt: null,
+        updatedAt: options.timestamp,
+    };
+}
 function sourceProjectFromRecord(record) {
     return {
         projectId: record.projectId,
@@ -211,8 +277,4 @@ async function findWorkspaceForSource(options) {
         workspaces.find((workspace) => workspace.cwd === options.repoRoot && !workspace.archivedAt) ??
         null);
 }
-async function findWorkspaceByDirectory(cwd, workspaceRegistry) {
-    const workspaces = await workspaceRegistry.list();
-    return workspaces.find((workspace) => workspace.cwd === cwd) ?? null;
-}
 //# sourceMappingURL=paseo-worktree-service.js.map

package/dist/server/server/path-utils.d.ts

@@ -1,3 +1,4 @@
+export declare function assertAbsolutePath(cwd: string): void;
 export declare function expandUserPath(value: string): string;
 export declare function resolvePathFromBase(baseCwd: string, requestedPath: string): string;
 export declare function isSameOrDescendantPath(basePath: string, candidatePath: string): boolean;

package/dist/server/server/path-utils.js

@@ -1,5 +1,10 @@
 import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute, posix, resolve, win32 } from "node:path";
+export function assertAbsolutePath(cwd) {
+    if (!posix.isAbsolute(cwd) && !win32.isAbsolute(cwd)) {
+        throw new Error("cwd must be absolute path");
+    }
+}
 function hasHomePrefix(value) {
     return value === "~" || value.startsWith("~/");
 }

package/dist/server/server/persisted-config.d.ts

@@ -20,6 +20,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             injectIntoAgents: z.ZodOptional<z.ZodBoolean>;
         }, z.ZodTypeAny, "passthrough">>>;
         autoArchiveAfterMerge: z.ZodOptional<z.ZodBoolean>;
+        enableTerminalAgentHooks: z.ZodOptional<z.ZodBoolean>;
         appendSystemPrompt: z.ZodOptional<z.ZodString>;
         terminalProfiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -98,6 +99,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -133,6 +135,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;
@@ -167,6 +170,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -202,6 +206,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;
@@ -899,6 +904,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         listen?: string | undefined;
         hostnames?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectOutputType<{
             id: z.ZodString;
@@ -1045,6 +1051,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
         hostnames?: true | string[] | undefined;
         allowedHosts?: true | string[] | undefined;
         autoArchiveAfterMerge?: boolean | undefined;
+        enableTerminalAgentHooks?: boolean | undefined;
         appendSystemPrompt?: string | undefined;
         terminalProfiles?: z.objectInputType<{
             id: z.ZodString;

package/dist/server/server/persisted-config.js

@@ -187,6 +187,7 @@ export const PersistedConfigSchema = z
             .passthrough()
             .optional(),
         autoArchiveAfterMerge: z.boolean().optional(),
+        enableTerminalAgentHooks: z.boolean().optional(),
         appendSystemPrompt: z.string().optional(),
         terminalProfiles: z.array(TerminalProfileSchema).optional(),
         cors: z

package/dist/server/server/persistence-hooks.d.ts

@@ -24,6 +24,7 @@ export declare function extractTimestamps(record: StoredAgentRecord): {
     updatedAt: Date;
     lastUserMessageAt: Date | null;
     labels?: Record<string, string>;
+    workspaceId?: string;
 };
 export declare function toAgentPersistenceHandle(registeredProviders: Iterable<AgentProvider>, handle: StoredAgentRecord["persistence"]): AgentPersistenceHandle | null;
 export {};

package/dist/server/server/persistence-hooks.js

@@ -2,6 +2,15 @@ import { stripInternalPaseoMcpServer } from "./agent/runtime-mcp-config.js";
 function getLogger(logger) {
     return logger.child({ module: "persistence" });
 }
+function isProviderRegistered(validProviders, provider) {
+    if (!validProviders) {
+        return true;
+    }
+    if (validProviders instanceof Set) {
+        return validProviders.has(provider);
+    }
+    return new Set(validProviders).has(provider);
+}
 /**
  * Attach AgentStorage persistence to an AgentManager instance so every
  * agent_state snapshot is flushed to disk.
@@ -35,9 +44,7 @@ export function buildConfigOverrides(record) {
     });
 }
 export function buildSessionConfig(record, options) {
-    const validProviders = options?.validProviders;
-    const isValidProvider = validProviders ? new Set(validProviders).has(record.provider) : true;
-    if (!isValidProvider) {
+    if (!isProviderRegistered(options?.validProviders, record.provider)) {
         return null;
     }
     const overrides = buildConfigOverrides(record);
@@ -54,7 +61,7 @@ export function buildSessionConfig(record, options) {
     });
 }
 export function isStoredAgentProviderAvailable(record, validProviders) {
-    return buildSessionConfig(record, { validProviders }) !== null;
+    return isProviderRegistered(validProviders, record.provider);
 }
 export function extractTimestamps(record) {
     return {
@@ -62,6 +69,7 @@ export function extractTimestamps(record) {
         updatedAt: new Date(record.lastActivityAt ?? record.updatedAt),
         lastUserMessageAt: record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null,
         labels: record.labels,
+        workspaceId: record.workspaceId,
     };
 }
 export function toAgentPersistenceHandle(registeredProviders, handle) {
@@ -69,7 +77,7 @@ export function toAgentPersistenceHandle(registeredProviders, handle) {
         return null;
     }
     const provider = handle.provider;
-    if (!new Set(registeredProviders).has(provider)) {
+    if (!isProviderRegistered(registeredProviders, provider)) {
         return null;
     }
     if (!handle.sessionId) {

package/dist/server/server/resolve-workspace-id-for-path.d.ts

@@ -0,0 +1,3 @@
+import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
+export declare function resolveWorkspaceIdForPath(cwd: string, workspaces: Iterable<PersistedWorkspaceRecord>): string | null;
+//# sourceMappingURL=resolve-workspace-id-for-path.d.ts.map

package/dist/server/server/resolve-workspace-id-for-path.js

@@ -0,0 +1,41 @@
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// external path→workspace adapter, not ownership.
+//
+// Resolves a raw filesystem path to a single workspace id ONLY at the boundary
+// where a client hands the daemon a bare worktree path with no id:
+// archive-by-path (old client / CLI), auto-archive-after-merge, and the MCP
+// `archive_worktree` tool. It is NEVER used to attribute agent status or place
+// agents under a workspace — those are keyed by `workspaceId`, and git facts
+// derive from a workspace's OWN cwd (id → cwd).
+//
+// Resolution: an exact directory match wins; otherwise the deepest enclosing
+// workspace directory, never the home directory; null when nothing encloses it.
+export function resolveWorkspaceIdForPath(cwd, workspaces) {
+    const workspaceRecords = Array.from(workspaces);
+    const resolvedCwd = resolve(cwd);
+    const exactMatch = workspaceRecords.find((workspace) => resolve(workspace.cwd) === resolvedCwd);
+    if (exactMatch) {
+        return exactMatch.workspaceId;
+    }
+    const userHome = resolve(homedir());
+    let bestMatchLength = 0;
+    let bestMatch = null;
+    for (const workspace of workspaceRecords) {
+        if (workspace.archivedAt)
+            continue;
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome)
+            continue;
+        const prefix = workspaceCwd.endsWith(sep) ? workspaceCwd : `${workspaceCwd}${sep}`;
+        if (!resolvedCwd.startsWith(prefix)) {
+            continue;
+        }
+        if (workspaceCwd.length > bestMatchLength) {
+            bestMatchLength = workspaceCwd.length;
+            bestMatch = workspace;
+        }
+    }
+    return bestMatch?.workspaceId ?? null;
+}
+//# sourceMappingURL=resolve-workspace-id-for-path.js.map

package/dist/server/server/script-proxy.d.ts

@@ -1,3 +1,3 @@
-export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } from "./service-proxy.js";
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
 export type { ScriptRoute, ScriptRouteEntry } from "./service-proxy.js";
 //# sourceMappingURL=script-proxy.d.ts.map

package/dist/server/server/script-proxy.js

@@ -1,2 +1,2 @@
-export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, } from "./service-proxy.js";
+export { createScriptProxyMiddleware, createScriptProxyUpgradeHandler, findFreePort, ScriptRouteStore, ServiceProxyRouteCollisionError, } from "./service-proxy.js";
 //# sourceMappingURL=script-proxy.js.map

package/dist/server/server/service-proxy.js

@@ -187,7 +187,7 @@ function sameRouteOwner(left, right) {
 }
 export class ServiceProxyRouteCollisionError extends Error {
     constructor(hostname, existing, incoming) {
-        super(`Service proxy hostname collision for ${hostname}: ${existing.workspaceId}/${existing.scriptName} already owns it`);
+        super(`Another workspace is already serving "${incoming.scriptName}" at ${hostname}. Stop that service or run this one on a different branch to free the address.`);
         this.hostname = hostname;
         this.existing = existing;
         this.incoming = incoming;