@getpaseo/server 0.1.96 → 0.1.97-beta.1

package/dist/server/server/workspace-registry-bootstrap.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { classifyDirectoryForProjectMembership, normalizeWorkspaceId, } from "./workspace-registry-model.js";
+import { classifyDirectoryForProjectMembership, generateWorkspaceId, } from "./workspace-registry-model.js";
+import { backfillWorkspaceIdForLegacyAgents } from "./migrations/backfill-workspace-id.migration.js";
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
 function minIsoDate(left, right) {
     if (!left) {
@@ -32,28 +33,33 @@ export async function bootstrapWorkspaceRegistries(options) {
     ]);
     await Promise.all([options.projectRegistry.initialize(), options.workspaceRegistry.initialize()]);
     if (projectsExists && workspacesExists) {
+        await backfillWorkspaceIdForLegacyAgents(options);
         return;
     }
+    const existingWorkspaceIdsByCwd = new Map((await options.workspaceRegistry.list()).map((workspace) => [
+        path.resolve(workspace.cwd),
+        workspace.workspaceId,
+    ]));
     const records = await options.agentStorage.list();
     const activeRecords = records.filter((record) => !record.archivedAt);
-    const recordsByWorkspaceId = new Map();
+    const recordsByDirectoryKey = new Map();
     const placements = await Promise.all(activeRecords.map(async (record) => {
-        const normalizedCwd = normalizeWorkspaceId(record.cwd);
+        const normalizedCwd = path.resolve(record.cwd);
         const checkout = await options.workspaceGitService.getCheckout(normalizedCwd);
         const membership = classifyDirectoryForProjectMembership({
             cwd: normalizedCwd,
             checkout,
         });
-        return { record, membership, workspaceId: membership.workspaceId };
+        return { record, membership, directoryKey: membership.workspaceDirectoryKey };
     }));
-    for (const { record, membership, workspaceId } of placements) {
-        const existing = recordsByWorkspaceId.get(workspaceId) ?? { membership, records: [] };
+    for (const { record, membership, directoryKey } of placements) {
+        const existing = recordsByDirectoryKey.get(directoryKey) ?? { membership, records: [] };
         existing.records.push(record);
-        recordsByWorkspaceId.set(workspaceId, existing);
+        recordsByDirectoryKey.set(directoryKey, existing);
     }
     const projectRanges = new Map();
     const workspaceUpsertInputs = [];
-    for (const [workspaceId, entry] of recordsByWorkspaceId.entries()) {
+    for (const entry of recordsByDirectoryKey.values()) {
         const { membership, records: workspaceRecords } = entry;
         const workspaceCwd = membership.checkout.cwd;
         let workspaceCreatedAt = null;
@@ -71,7 +77,13 @@ export async function bootstrapWorkspaceRegistries(options) {
         existingProjectRange.createdAt = minIsoDate(existingProjectRange.createdAt, createdAt);
         existingProjectRange.updatedAt = maxIsoDate(existingProjectRange.updatedAt, updatedAt);
         projectRanges.set(membership.projectKey, existingProjectRange);
-        workspaceUpsertInputs.push({ workspaceId, membership, workspaceCwd, createdAt, updatedAt });
+        workspaceUpsertInputs.push({
+            workspaceId: existingWorkspaceIdsByCwd.get(workspaceCwd) ?? generateWorkspaceId(),
+            membership,
+            workspaceCwd,
+            createdAt,
+            updatedAt,
+        });
     }
     await Promise.all(workspaceUpsertInputs.flatMap(({ workspaceId, membership, workspaceCwd, createdAt, updatedAt }) => {
         const projectRange = projectRanges.get(membership.projectKey) ?? {
@@ -98,11 +110,12 @@ export async function bootstrapWorkspaceRegistries(options) {
             })),
         ];
     }));
+    await backfillWorkspaceIdForLegacyAgents(options);
     options.logger.info({
         projectsFile: path.join(options.paseoHome, "projects", "projects.json"),
         workspacesFile: path.join(options.paseoHome, "projects", "workspaces.json"),
         materializedProjects: projectRanges.size,
-        materializedWorkspaces: recordsByWorkspaceId.size,
+        materializedWorkspaces: recordsByDirectoryKey.size,
     }, "Workspace registries bootstrapped from existing agent storage");
 }
 //# sourceMappingURL=workspace-registry-bootstrap.js.map

package/dist/server/server/workspace-registry-model.d.ts

@@ -5,7 +5,7 @@ export type PersistedWorkspaceKind = "local_checkout" | "worktree" | "directory"
 export interface DirectoryProjectMembership {
     cwd: string;
     checkout: ProjectCheckoutLitePayload;
-    workspaceId: string;
+    workspaceDirectoryKey: string;
     workspaceKind: PersistedWorkspaceKind;
     workspaceDisplayName: string;
     projectKey: string;
@@ -17,8 +17,8 @@ export interface DetectStaleWorkspacesInput {
     activeWorkspaces: PersistedWorkspaceRecord[];
     checkDirectoryExists: (cwd: string) => Promise<boolean>;
 }
-export declare function normalizeWorkspaceId(cwd: string): string;
-export declare function deriveWorkspaceId(cwd: string, checkout: ProjectCheckoutLitePayload): string;
+export declare function generateWorkspaceId(): string;
+export declare function deriveWorkspaceDirectoryKey(cwd: string, checkout: ProjectCheckoutLitePayload): string;
 export declare function deriveProjectGroupingKey(options: {
     cwd: string;
     remoteUrl: string | null;

package/dist/server/server/workspace-registry-model.js

@@ -1,15 +1,14 @@
+import { randomBytes } from "node:crypto";
 import { resolve } from "node:path";
 import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
-export function normalizeWorkspaceId(cwd) {
-    const trimmed = cwd.trim();
-    if (!trimmed) {
-        return cwd;
-    }
-    return resolve(trimmed);
+export function generateWorkspaceId() {
+    return `wks_${randomBytes(8).toString("hex")}`;
 }
-export function deriveWorkspaceId(cwd, checkout) {
+// Path-derived grouping key for a workspace directory. This is NOT the opaque
+// workspace identity (see generateWorkspaceId); never persist or compare it as one.
+export function deriveWorkspaceDirectoryKey(cwd, checkout) {
     const worktreeRoot = checkout.worktreeRoot ? parseGitRevParsePath(checkout.worktreeRoot) : null;
-    return worktreeRoot ?? normalizeWorkspaceId(cwd);
+    return worktreeRoot ?? resolve(cwd);
 }
 function deriveRemoteProjectKey(remoteUrl) {
     if (!remoteUrl) {
@@ -160,7 +159,7 @@ export function buildProjectPlacementForCwd(input) {
     };
 }
 export function classifyDirectoryForProjectMembership(input) {
-    const normalizedCwd = normalizeWorkspaceId(input.cwd);
+    const normalizedCwd = resolve(input.cwd);
     const checkout = {
         ...input.checkout,
         cwd: normalizedCwd,
@@ -173,7 +172,7 @@ export function classifyDirectoryForProjectMembership(input) {
     return {
         cwd: normalizedCwd,
         checkout,
-        workspaceId: deriveWorkspaceId(normalizedCwd, checkout),
+        workspaceDirectoryKey: deriveWorkspaceDirectoryKey(normalizedCwd, checkout),
         workspaceKind: deriveWorkspaceKind(checkout),
         workspaceDisplayName: deriveWorkspaceDisplayName({
             cwd: normalizedCwd,

package/dist/server/server/workspace-registry.d.ts

@@ -11,19 +11,19 @@ declare const PersistedProjectRecordSchema: z.ZodObject<{
     updatedAt: z.ZodString;
     archivedAt: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    kind: "git" | "non_git";
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "git" | "non_git";
     projectId: string;
     displayName: string;
     rootPath: string;
     customName: string | null;
 }, {
+    kind: "git" | "non_git";
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "git" | "non_git";
     projectId: string;
     displayName: string;
     rootPath: string;
@@ -35,27 +35,33 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     cwd: z.ZodString;
     kind: z.ZodEnum<["local_checkout", "worktree", "directory"]>;
     displayName: z.ZodString;
+    title: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null, string | null | undefined>;
+    branch: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null, string | null | undefined>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     archivedAt: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    kind: "local_checkout" | "worktree" | "directory";
     workspaceId: string;
     cwd: string;
+    title: string | null;
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "local_checkout" | "worktree" | "directory";
     projectId: string;
     displayName: string;
+    branch: string | null;
 }, {
+    kind: "local_checkout" | "worktree" | "directory";
     workspaceId: string;
     cwd: string;
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "local_checkout" | "worktree" | "directory";
     projectId: string;
     displayName: string;
+    title?: string | null | undefined;
+    branch?: string | null | undefined;
 }>;
 export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
 export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;
@@ -127,9 +133,16 @@ export declare function createPersistedWorkspaceRecord(input: {
     cwd: string;
     kind: PersistedWorkspaceKind;
     displayName: string;
+    title?: string | null;
+    branch?: string | null;
     createdAt: string;
     updatedAt: string;
     archivedAt?: string | null;
 }): PersistedWorkspaceRecord;
+export declare function resolveWorkspaceName(input: {
+    title: string | null;
+    derivedDisplayName: string;
+}): string;
+export declare function resolveWorkspaceDisplayName(record: PersistedWorkspaceRecord): string;
 export {};
 //# sourceMappingURL=workspace-registry.d.ts.map

package/dist/server/server/workspace-registry.js

@@ -23,6 +23,22 @@ const PersistedWorkspaceRecordSchema = z.object({
     cwd: z.string(),
     kind: z.enum(["local_checkout", "worktree", "directory"]),
     displayName: z.string(),
+    // User-set title layered over the derived displayName. In Model B the title is
+    // the workspace identity; branch/directory are backing metadata. Reconciliation
+    // never touches this. Null means "use the derived displayName".
+    title: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
+    // The worktree's git branch. Decoupled from displayName/title by construction:
+    // displayName holds the human name (title), branch holds the git branch. Only
+    // worktree workspaces carry a branch; directory/local_checkout leave it null.
+    branch: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
     createdAt: z.string(),
     updatedAt: z.string(),
     archivedAt: z.string().nullable(),
@@ -152,7 +168,18 @@ export function resolveProjectDisplayName(record) {
 export function createPersistedWorkspaceRecord(input) {
     return PersistedWorkspaceRecordSchema.parse({
         ...input,
+        title: input.title ?? null,
+        branch: input.branch ?? null,
         archivedAt: input.archivedAt ?? null,
     });
 }
+// The single workspace-name rule: the user-set title always wins; otherwise fall
+// back to the freshest available derived display name (a live branch snapshot when
+// the caller has one, the persisted displayName otherwise).
+export function resolveWorkspaceName(input) {
+    return input.title ?? input.derivedDisplayName;
+}
+export function resolveWorkspaceDisplayName(record) {
+    return resolveWorkspaceName({ title: record.title, derivedDisplayName: record.displayName });
+}
 //# sourceMappingURL=workspace-registry.js.map

package/dist/server/server/worktree/commands.d.ts

@@ -1,4 +1,4 @@
-import { type ArchivePaseoWorktreeDependencies } from "../paseo-worktree-archive-service.js";
+import { type ArchiveDependencies, type ArchiveScope } from "../workspace-archive-service.js";
 import type { CreatePaseoWorktreeInput, CreatePaseoWorktreeResult } from "../paseo-worktree-service.js";
 import { type WorktreeWireError } from "../worktree-errors.js";
 import type { WorkspaceGitService, WorkspaceGitWorktreeInfo } from "../workspace-git-service.js";
@@ -29,17 +29,19 @@ export type CreatePaseoWorktreeCommandResult<Result extends CreatePaseoWorktreeR
     cause: unknown;
 };
 export declare function createPaseoWorktreeCommand<Result extends CreatePaseoWorktreeResult>(dependencies: CreatePaseoWorktreeCommandDependencies<Result>, input: CreatePaseoWorktreeCommandInput): Promise<CreatePaseoWorktreeCommandResult<Result>>;
-export interface ArchivePaseoWorktreeCommandDependencies extends Omit<ArchivePaseoWorktreeDependencies, "workspaceGitService"> {
+export interface ArchiveCommandDependencies extends Omit<ArchiveDependencies, "workspaceGitService"> {
     workspaceGitService: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees">;
 }
-export interface ArchivePaseoWorktreeCommandInput {
+export interface ArchiveCommandInput {
     requestId: string;
     repoRoot?: string | null;
     worktreePath?: string;
     worktreeSlug?: string;
     branchName?: string;
+    workspaceId?: string;
+    scope?: ArchiveScope["kind"];
 }
-export type ArchivePaseoWorktreeCommandResult = {
+export type ArchiveCommandResult = {
     ok: true;
     removedAgents: string[];
 } | {
@@ -48,6 +50,6 @@ export type ArchivePaseoWorktreeCommandResult = {
     message: string;
     removedAgents: [];
 };
-export declare function archivePaseoWorktreeCommand(dependencies: ArchivePaseoWorktreeCommandDependencies, input: ArchivePaseoWorktreeCommandInput): Promise<ArchivePaseoWorktreeCommandResult>;
+export declare function archiveCommand(dependencies: ArchiveCommandDependencies, input: ArchiveCommandInput): Promise<ArchiveCommandResult>;
 export {};
 //# sourceMappingURL=commands.d.ts.map

package/dist/server/server/worktree/commands.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { getPaseoWorktreesRoot, isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
-import { archivePaseoWorktree, } from "../paseo-worktree-archive-service.js";
+import { archiveByScope, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
 import { toWorktreeWireError } from "../worktree-errors.js";
 export async function listPaseoWorktreesCommand(dependencies, input) {
     if (input.reason) {
@@ -29,31 +29,51 @@ export async function createPaseoWorktreeCommand(dependencies, input) {
         };
     }
 }
-export async function archivePaseoWorktreeCommand(dependencies, input) {
+export async function archiveCommand(dependencies, input) {
     const resolvedTarget = await resolveArchiveTarget(dependencies, input);
-    const ownership = await isPaseoOwnedWorktreeCwd(resolvedTarget.targetPath, {
-        paseoHome: dependencies.paseoHome,
-        worktreesRoot: dependencies.worktreesRoot,
-    });
-    if (!ownership.allowed) {
+    const scope = input.scope ?? "workspace";
+    if (scope === "worktree") {
+        const ownership = await isPaseoOwnedWorktreeCwd(resolvedTarget.targetPath, {
+            paseoHome: dependencies.paseoHome,
+            worktreesRoot: dependencies.paseoWorktreesBaseRoot,
+        });
+        if (!ownership.allowed) {
+            return {
+                ok: false,
+                code: "NOT_ALLOWED",
+                message: "Worktree is not a Paseo-owned worktree",
+                removedAgents: [],
+            };
+        }
+        const result = await archiveByScope(dependencies, {
+            scope: { kind: "worktree", targetPath: resolvedTarget.targetPath },
+            repoRoot: ownership.repoRoot ?? resolvedTarget.repoRoot ?? null,
+            repoWorktreesRoot: ownership.worktreeRoot,
+            paseoWorktreesBaseRoot: dependencies.paseoWorktreesBaseRoot,
+            requestId: input.requestId,
+        });
         return {
-            ok: false,
-            code: "NOT_ALLOWED",
-            message: "Worktree is not a Paseo-owned worktree",
+            ok: true,
+            removedAgents: result.archivedAgentIds,
+        };
+    }
+    const workspaceId = input.workspaceId ?? (await resolveWorkspaceIdAtPath(dependencies, resolvedTarget.targetPath));
+    if (!workspaceId) {
+        dependencies.sessionLogger?.warn({ targetPath: resolvedTarget.targetPath }, "Could not resolve workspace for archive; skipping");
+        return {
+            ok: true,
             removedAgents: [],
         };
     }
-    const repoRoot = ownership.repoRoot ?? resolvedTarget.repoRoot ?? null;
-    const removedAgents = await archivePaseoWorktree(dependencies, {
-        targetPath: resolvedTarget.targetPath,
-        repoRoot,
-        worktreesRoot: ownership.worktreeRoot,
-        worktreesBaseRoot: dependencies.worktreesRoot,
+    const result = await archiveByScope(dependencies, {
+        scope: { kind: "workspace", workspaceId },
+        repoRoot: resolvedTarget.repoRoot,
+        paseoWorktreesBaseRoot: dependencies.paseoWorktreesBaseRoot,
         requestId: input.requestId,
     });
     return {
         ok: true,
-        removedAgents,
+        removedAgents: result.archivedAgentIds,
     };
 }
 async function resolveArchiveTarget(dependencies, input) {
@@ -81,7 +101,7 @@ async function resolveArchiveTarget(dependencies, input) {
     throw new Error("worktreePath, worktreeSlug, or repoRoot+branchName is required");
 }
 async function resolveWorktreeSlugPath(dependencies, repoRoot, worktreeSlug) {
-    const worktreesRoot = await getPaseoWorktreesRoot(repoRoot, dependencies.paseoHome, dependencies.worktreesRoot);
+    const worktreesRoot = await getPaseoWorktreesRoot(repoRoot, dependencies.paseoHome, dependencies.paseoWorktreesBaseRoot);
     return join(worktreesRoot, worktreeSlug);
 }
 //# sourceMappingURL=commands.js.map

package/dist/server/server/worktree-bootstrap.d.ts

@@ -13,6 +13,7 @@ export interface WorktreeBootstrapTerminalResult {
 }
 export interface RunAsyncWorktreeBootstrapOptions {
     agentId: string;
+    workspaceId: string;
     worktree: WorktreeConfig;
     shouldBootstrap?: boolean;
     terminalManager: TerminalManager | null;

package/dist/server/server/worktree-bootstrap.js

@@ -383,6 +383,7 @@ async function runWorktreeTerminalBootstrap(options, runtimeEnv) {
                 cwd: options.worktree.worktreePath,
                 name: spec.name,
                 env: runtimeEnv,
+                workspaceId: options.workspaceId,
             });
             await waitForTerminalBootstrapReadiness(terminal);
             terminal.send({
@@ -550,7 +551,7 @@ async function setupServiceScriptRoute(params) {
     return { hostname: registeredRoute.hostname, port, env };
 }
 async function acquireWorkspaceScriptTerminal(params) {
-    const { serviceScript, existingRuntimeEntry, terminalManager, repoRoot, scriptName, env } = params;
+    const { serviceScript, existingRuntimeEntry, terminalManager, repoRoot, workspaceId, scriptName, env, } = params;
     let reusableTerminal = null;
     if (!serviceScript && existingRuntimeEntry?.terminalId) {
         reusableTerminal = terminalManager.getTerminal(existingRuntimeEntry.terminalId) ?? null;
@@ -558,6 +559,7 @@ async function acquireWorkspaceScriptTerminal(params) {
     const terminal = reusableTerminal ??
         (await terminalManager.createTerminal({
             cwd: repoRoot,
+            workspaceId,
             name: scriptName,
             title: scriptName,
             env,
@@ -612,6 +614,7 @@ export async function spawnWorkspaceScript(options) {
             existingRuntimeEntry,
             terminalManager,
             repoRoot,
+            workspaceId,
             scriptName,
             env,
         });

package/dist/server/server/worktree-branch-name-generator.d.ts

@@ -26,6 +26,10 @@ export interface GenerateBranchNameFromFirstAgentContextOptions {
         generateStructuredAgentResponseWithFallback?: typeof generateStructuredAgentResponseWithFallback;
     };
 }
-export declare function generateBranchNameFromFirstAgentContext(options: GenerateBranchNameFromFirstAgentContextOptions): Promise<string | null>;
+export interface GeneratedWorkspaceName {
+    title: string | null;
+    branch: string | null;
+}
+export declare function generateBranchNameFromFirstAgentContext(options: GenerateBranchNameFromFirstAgentContextOptions): Promise<GeneratedWorkspaceName | null>;
 export {};
 //# sourceMappingURL=worktree-branch-name-generator.d.ts.map

package/dist/server/server/worktree-branch-name-generator.js

@@ -4,6 +4,7 @@ import { resolveStructuredGenerationProviders, } from "./agent/structured-genera
 import { buildAgentBranchNameSeed } from "./agent/prompt-attachments.js";
 import { buildMetadataPrompt } from "../utils/build-metadata-prompt.js";
 const BranchNameSchema = z.object({
+    title: z.string().min(1).max(80),
     branch: z.string().min(1).max(100),
 });
 async function buildPrompt(seed, options) {
@@ -13,10 +14,12 @@ async function buildPrompt(seed, options) {
         configKey: "branchName",
         before: [
             "Generate a git branch name for a coding agent based on the user prompt and attachments.",
+            "Title: a short human-readable sentence-case label for the task (no slug rules, max 80 characters).",
             "Branch: concise lowercase slug using letters, numbers, hyphens, and slashes only.",
             "No spaces, no uppercase, no leading or trailing hyphen, no consecutive hyphens.",
+            "The branch is generated directly from the prompt — it is NEVER derived from or slugified from the title.",
         ].join("\n"),
-        after: "Return JSON only with a single field 'branch'.",
+        after: "Return JSON only with fields 'title' and 'branch'.",
         trailing: `User context:\n${seed}`,
     });
 }
@@ -54,7 +57,10 @@ export async function generateBranchNameFromFirstAgentContext(options) {
                 internal: true,
             },
         });
-        return result.branch.trim() || null;
+        return {
+            title: result.title.trim() || null,
+            branch: result.branch.trim() || null,
+        };
     }
     catch (error) {
         const attempts = error instanceof StructuredAgentFallbackError ? error.attempts : undefined;

package/dist/server/server/worktree-session.d.ts

@@ -11,7 +11,7 @@ import type { GitHubService } from "../services/github-service.js";
 import type { CheckoutExistingBranchResult } from "../utils/checkout-git.js";
 import { type WorktreeConfig } from "../utils/worktree.js";
 import type { CreatePaseoWorktreeInput, CreatePaseoWorktreeResult } from "./paseo-worktree-service.js";
-import type { ArchivePaseoWorktreeDependencies } from "./paseo-worktree-archive-service.js";
+import type { ArchiveDependencies } from "./workspace-archive-service.js";
 export interface NormalizedGitOptions {
     baseBranch?: string;
     createNewBranch: boolean;
@@ -49,9 +49,7 @@ interface BuildAgentSessionConfigDependencies {
 interface CreatePaseoWorktreeInBackgroundDependencies {
     paseoHome?: string;
     worktreesRoot?: string;
-    emitWorkspaceUpdateForCwd: (cwd: string, options?: {
-        dedupeGitState?: boolean;
-    }) => Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId: (workspaceId: string) => Promise<void>;
     cacheWorkspaceSetupSnapshot: (workspaceId: string, snapshot: WorkspaceSetupSnapshot) => void;
     emit: EmitSessionMessage;
     sessionLogger: Logger;
@@ -112,6 +110,7 @@ interface HandleCreatePaseoWorktreeRequestDependencies {
 export declare function buildAgentSessionConfig(dependencies: BuildAgentSessionConfigDependencies, config: AgentSessionConfig, gitOptions?: GitSetupOptions, legacyWorktreeName?: string, firstAgentContext?: FirstAgentContext): Promise<{
     sessionConfig: AgentSessionConfig;
     setupContinuation?: AgentWorktreeSetupContinuation;
+    createdWorkspaceId?: string;
 }>;
 export declare function normalizeGitOptions(gitOptions?: GitSetupOptions, legacyWorktreeName?: string): NormalizedGitOptions | null;
 export declare function assertSafeGitRef(ref: string, label: string): void;
@@ -123,7 +122,7 @@ export declare function handlePaseoWorktreeListRequest(dependencies: {
 }, msg: Extract<SessionInboundMessage, {
     type: "paseo_worktree_list_request";
 }>): Promise<void>;
-export declare function handlePaseoWorktreeArchiveRequest(dependencies: Omit<ArchivePaseoWorktreeDependencies, "emitWorkspaceUpdatesForWorkspaceIds" | "workspaceGitService"> & {
+export declare function handlePaseoWorktreeArchiveRequest(dependencies: Omit<ArchiveDependencies, "emitWorkspaceUpdatesForWorkspaceIds" | "workspaceGitService"> & {
     emit: EmitSessionMessage;
     workspaceGitService: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees">;
     emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;

package/dist/server/server/worktree-session.js

@@ -4,7 +4,7 @@ import { expandTilde } from "../utils/path.js";
 import { getWorktreeSetupCommands, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, slugify, validateBranchSlug, WorktreeSetupError, } from "../utils/worktree.js";
 import { toCheckoutError } from "./checkout-git-utils.js";
 import { toWorktreeWireError } from "./worktree-errors.js";
-import { archivePaseoWorktreeCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "./worktree/commands.js";
+import { archiveCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "./worktree/commands.js";
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._/-]+$/;
 function normalizeFirstAgentContext(request) {
     if (request.firstAgentContext) {
@@ -22,6 +22,7 @@ export async function buildAgentSessionConfig(dependencies, config, gitOptions,
     let cwd = expandTilde(config.cwd);
     const normalized = normalizeGitOptions(gitOptions, legacyWorktreeName);
     let setupContinuation;
+    let createdWorkspaceId;
     if (!normalized) {
         return {
             sessionConfig: {
@@ -49,6 +50,7 @@ export async function buildAgentSessionConfig(dependencies, config, gitOptions,
         });
         cwd = createdWorktree.worktree.worktreePath;
         setupContinuation = createdWorktree.setupContinuation;
+        createdWorkspaceId = createdWorktree.workspace.workspaceId;
     }
     else if (normalized.createNewBranch) {
         const baseBranch = normalized.baseBranch ??
@@ -70,6 +72,7 @@ export async function buildAgentSessionConfig(dependencies, config, gitOptions,
             cwd,
         },
         setupContinuation,
+        createdWorkspaceId,
     };
 }
 function validateNormalizedGitOptions(input) {
@@ -195,11 +198,13 @@ export async function handlePaseoWorktreeListRequest(dependencies, msg) {
 export async function handlePaseoWorktreeArchiveRequest(dependencies, msg) {
     const { requestId } = msg;
     try {
-        const result = await archivePaseoWorktreeCommand(dependencies, {
+        const result = await archiveCommand(dependencies, {
             requestId,
             worktreePath: msg.worktreePath,
             repoRoot: msg.repoRoot,
             branchName: msg.branchName,
+            workspaceId: msg.workspaceId,
+            scope: msg.scope,
         });
         if (!result.ok) {
             dependencies.emit({
@@ -343,6 +348,7 @@ export async function createPaseoWorktreeWorkflow(dependencies, input, options)
                 startAfterAgentCreate: ({ agentId }) => {
                     void runAsyncWorktreeBootstrap({
                         agentId,
+                        workspaceId: workspace.workspaceId,
                         worktree: createdWorktree.worktree,
                         shouldBootstrap: createdWorktree.created,
                         terminalManager: setupContinuation.terminalManager,
@@ -454,7 +460,7 @@ export async function runWorktreeSetupInBackground(dependencies, options) {
         }
     }
     finally {
-        await dependencies.emitWorkspaceUpdateForCwd(worktree.worktreePath);
+        await dependencies.emitWorkspaceUpdateForWorkspaceId(options.workspaceId);
     }
 }
 //# sourceMappingURL=worktree-session.js.map

package/dist/server/services/github-service.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { findExecutable } from "../utils/executable.js";
+import { findExecutable } from "../executable-resolution/executable-resolution.js";
 import { resolveGitHubRemote } from "../utils/github-remote.js";
 import { runGitCommand } from "../utils/run-git-command.js";
 import { execCommand } from "../utils/spawn.js";

package/dist/server/terminal/activity/terminal-activity-tracker.d.ts

@@ -0,0 +1,20 @@
+import type { TerminalActivityAttentionReason, TerminalActivityState } from "@getpaseo/protocol/terminal-activity";
+export interface TerminalActivitySnapshot {
+    state: TerminalActivityState | null;
+    attentionReason: TerminalActivityAttentionReason | null;
+    changedAt: number;
+}
+export declare class TerminalActivityTracker {
+    private resolvedState;
+    private attentionReason;
+    private changedAt;
+    private readonly changeListeners;
+    set(state: TerminalActivityState): void;
+    clear(): void;
+    clearAttention(): boolean;
+    private setState;
+    onChange(listener: (snapshot: TerminalActivitySnapshot, previous: TerminalActivitySnapshot) => void): () => void;
+    getSnapshot(): TerminalActivitySnapshot;
+    dispose(): void;
+}
+//# sourceMappingURL=terminal-activity-tracker.d.ts.map

package/dist/server/terminal/activity/terminal-activity-tracker.js

@@ -0,0 +1,59 @@
+export class TerminalActivityTracker {
+    constructor() {
+        // unknown != idle: a plain shell, or a terminal whose agent was killed, has no dot or rollup.
+        this.resolvedState = null;
+        this.attentionReason = null;
+        this.changedAt = Date.now();
+        this.changeListeners = new Set();
+    }
+    set(state) {
+        if (state === "idle" && this.resolvedState === "working") {
+            this.setState("idle", "finished");
+            return;
+        }
+        if (state === "idle" && this.attentionReason === "finished") {
+            return;
+        }
+        this.setState(state === "attention" ? "idle" : state, state === "attention" ? "needs_input" : null);
+    }
+    clear() {
+        this.setState(null, null);
+    }
+    clearAttention() {
+        if (!this.attentionReason) {
+            return false;
+        }
+        this.setState("idle", null);
+        return true;
+    }
+    setState(state, attentionReason) {
+        if (state === this.resolvedState && attentionReason === this.attentionReason) {
+            return;
+        }
+        const previous = this.getSnapshot();
+        this.resolvedState = state;
+        this.attentionReason = attentionReason;
+        this.changedAt = Date.now();
+        const snapshot = this.getSnapshot();
+        for (const listener of Array.from(this.changeListeners)) {
+            listener(snapshot, previous);
+        }
+    }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    getSnapshot() {
+        return {
+            state: this.resolvedState,
+            attentionReason: this.attentionReason,
+            changedAt: this.changedAt,
+        };
+    }
+    dispose() {
+        this.changeListeners.clear();
+    }
+}
+//# sourceMappingURL=terminal-activity-tracker.js.map