@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,63 @@
+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 { ForgeService } from "../services/forge-service.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type { PersistedWorkspaceRecord, WorkspaceArchiveContext, WorkspaceRegistry } from "./workspace-registry.js";
+export type ActiveWorkspaceRef = Pick<PersistedWorkspaceRecord, "workspaceId" | "cwd" | "kind" | "worktreeRoot" | "isPaseoOwnedWorktree" | "mainRepoRoot">;
+export interface ArchiveDependencies {
+    paseoHome?: string;
+    paseoWorktreesBaseRoot?: string;
+    github: ForgeService;
+    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot">;
+    agentManager: Pick<AgentManager, "listAgents" | "getAgent" | "archiveAgent" | "archiveSnapshot">;
+    agentStorage: Pick<AgentStorage, "listByWorkspace">;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    getWorkspace?: (workspaceId: string) => Promise<PersistedWorkspaceRecord | 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>;
+    stopWorkspaceSetup?: (workspaceId: string) => Promise<void>;
+    assertWorkspaceAutomationAllowed?: (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;
+    requestId: string;
+}
+export declare function requireActiveWorkspaceForArchive(dependencies: Pick<ArchiveDependencies, "listActiveWorkspaces">, workspaceId: string): Promise<ActiveWorkspaceRef>;
+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;
+    context?: WorkspaceArchiveContext;
+}): Promise<PersistedWorkspaceRecord | null>;
+//# sourceMappingURL=workspace-archive-service.d.ts.map

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

@@ -0,0 +1,355 @@
+import { resolve } from "node:path";
+import { deletePaseoWorktree, isPaseoOwnedWorktreeCwd, runWorktreeTeardownCommands, WorktreeTeardownError, } from "../utils/worktree.js";
+import { createRealpathAwarePathMatcher } from "../utils/path.js";
+import { runWithGitCommandPriority } from "../utils/run-git-command.js";
+import { WorkspaceAutomationBlockedError } from "./workspace-automation-gate.js";
+export async function requireActiveWorkspaceForArchive(dependencies, workspaceId) {
+    const workspace = (await dependencies.listActiveWorkspaces()).find((candidate) => candidate.workspaceId === workspaceId);
+    if (!workspace) {
+        throw new Error(`Workspace not found: ${workspaceId}`);
+    }
+    return workspace;
+}
+export async function resolveWorkspaceIdAtPath(dependencies, targetPath) {
+    const matchesTarget = createRealpathAwarePathMatcher(targetPath);
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    const exactMatches = activeWorkspaces.filter((workspace) => matchesTarget(workspace.cwd));
+    const worktreeMatch = exactMatches.find((workspace) => workspace.kind === "worktree");
+    if (worktreeMatch) {
+        return worktreeMatch.workspaceId;
+    }
+    return dependencies.findWorkspaceIdForCwd(targetPath);
+}
+// 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) {
+    return runWithGitCommandPriority("high", () => archiveByScopeWithPriority(dependencies, request));
+}
+async function archiveByScopeWithPriority(dependencies, request) {
+    const target = await resolveArchiveTarget(dependencies, request.scope);
+    const targetWorkspaceIds = target.workspaceIds;
+    await stopWorkspaceSetups(dependencies, target.setupWorkspaceIds, request.requestId);
+    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 (target.backing?.mainRepoRoot) {
+            try {
+                await dependencies.workspaceGitService.getSnapshot(target.backing.mainRepoRoot, {
+                    force: true,
+                    reason: "archive-worktree",
+                });
+            }
+            catch (error) {
+                dependencies.sessionLogger?.warn({ err: error, cwd: target.backing.mainRepoRoot, requestId: request.requestId }, "Failed to force-refresh workspace git snapshot after archiving");
+            }
+        }
+        if (target.backing !== null) {
+            removedDirectory = await maybeRemoveDirectory(dependencies, request, target, archivedWorkspaceIds);
+        }
+        return {
+            archivedAgentIds: Array.from(archivedAgents),
+            archivedWorkspaceIds,
+            removedDirectory,
+        };
+    }
+    finally {
+        if (targetWorkspaceIds.length > 0) {
+            dependencies.clearWorkspaceArchiving(targetWorkspaceIds);
+            await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
+        }
+    }
+}
+async function resolveArchiveTarget(dependencies, scope) {
+    const activeWorkspaces = await dependencies.listActiveWorkspaces();
+    if (scope.kind === "workspace") {
+        const workspaceId = scope.workspaceId;
+        const record = (await dependencies.getWorkspace?.(workspaceId)) ??
+            activeWorkspaces.find((workspace) => workspace.workspaceId === workspaceId);
+        if (!record) {
+            dependencies.sessionLogger?.warn({ workspaceId }, "Workspace not found for archive-by-scope; skipping");
+            return { backing: null, teardownTargets: [], setupWorkspaceIds: [], workspaceIds: [] };
+        }
+        const isArchived = "archivedAt" in record && Boolean(record.archivedAt);
+        return {
+            backing: await resolveWorkspaceBackingDirectory(record, dependencies),
+            teardownTargets: isArchived ? [] : [{ workspaceId, cwd: record.cwd }],
+            setupWorkspaceIds: [workspaceId],
+            workspaceIds: isArchived ? [] : [workspaceId],
+        };
+    }
+    const backing = await resolveBackingDirectory(scope.targetPath, dependencies);
+    const matchesBackingDirectory = createRealpathAwarePathMatcher(backing.path);
+    const targetWorkspaces = (await Promise.all(activeWorkspaces.map(async (workspace) => {
+        const backingDirectory = await resolveWorkspaceBackingDirectory(workspace, dependencies);
+        return matchesBackingDirectory(backingDirectory.path) ? workspace : null;
+    }))).filter((workspace) => workspace !== null);
+    const persistedMainRepoRoot = targetWorkspaces.find((workspace) => workspace.mainRepoRoot)?.mainRepoRoot;
+    return {
+        backing: {
+            ...backing,
+            mainRepoRoot: persistedMainRepoRoot ?? backing.mainRepoRoot,
+        },
+        teardownTargets: targetWorkspaces.length > 0
+            ? targetWorkspaces.map((workspace) => ({
+                workspaceId: workspace.workspaceId,
+                cwd: workspace.cwd,
+            }))
+            : [{ workspaceId: null, cwd: scope.targetPath }],
+        setupWorkspaceIds: targetWorkspaces.map((workspace) => workspace.workspaceId),
+        workspaceIds: targetWorkspaces.map((workspace) => workspace.workspaceId),
+    };
+}
+async function stopWorkspaceSetups(dependencies, workspaceIds, requestId) {
+    if (!dependencies.stopWorkspaceSetup) {
+        return;
+    }
+    const results = await Promise.allSettled(workspaceIds.map((workspaceId) => dependencies.stopWorkspaceSetup(workspaceId)));
+    for (const [index, result] of results.entries()) {
+        if (result?.status === "rejected") {
+            dependencies.sessionLogger?.warn({ err: result.reason, workspaceId: workspaceIds[index], requestId }, "Failed to stop workspace setup during archive; continuing");
+        }
+    }
+}
+async function resolveWorkspaceBackingDirectory(workspace, dependencies) {
+    if (workspace.isPaseoOwnedWorktree && workspace.worktreeRoot && workspace.mainRepoRoot) {
+        return {
+            path: resolve(workspace.worktreeRoot),
+            isPaseoOwnedWorktree: true,
+            mainRepoRoot: workspace.mainRepoRoot,
+            paseoWorktreesRoot: null,
+        };
+    }
+    if (workspace.kind !== "worktree") {
+        return {
+            path: resolve(workspace.cwd),
+            isPaseoOwnedWorktree: false,
+            mainRepoRoot: workspace.mainRepoRoot ?? null,
+            paseoWorktreesRoot: null,
+        };
+    }
+    // COMPAT(archiveMissingWorkspacePlacement): worktree records created before v0.1.110
+    // lack durable backing ownership; remove filesystem discovery after 2027-01-17.
+    const backing = await resolveBackingDirectory(workspace.worktreeRoot ?? workspace.cwd, dependencies);
+    return { ...backing, mainRepoRoot: workspace.mainRepoRoot ?? backing.mainRepoRoot };
+}
+async function resolveBackingDirectory(cwd, dependencies) {
+    const options = {
+        paseoHome: dependencies.paseoHome,
+        worktreesRoot: dependencies.paseoWorktreesBaseRoot,
+    };
+    const ownership = await isPaseoOwnedWorktreeCwd(cwd, options);
+    return {
+        path: resolve(ownership.allowed && ownership.worktreePath ? ownership.worktreePath : cwd),
+        isPaseoOwnedWorktree: ownership.allowed,
+        mainRepoRoot: ownership.repoRoot ?? null,
+        paseoWorktreesRoot: ownership.worktreeRoot ?? null,
+    };
+}
+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, target, archivedWorkspaceIds) {
+    const backing = target.backing;
+    if (!backing?.isPaseoOwnedWorktree) {
+        return false;
+    }
+    const archivedWorkspaceIdSet = new Set(archivedWorkspaceIds);
+    const teardownTargets = target.teardownTargets.filter((teardownTarget) => teardownTarget.workspaceId === null || archivedWorkspaceIdSet.has(teardownTarget.workspaceId));
+    try {
+        const allowedTeardownTargets = await filterAllowedTeardownTargets(dependencies, teardownTargets);
+        for (const teardownTarget of uniqueTeardownTargets(allowedTeardownTargets)) {
+            await runWorktreeTeardownCommands({
+                worktreePath: backing.path,
+                teardownCwd: teardownTarget.cwd,
+                repoRootPath: backing.mainRepoRoot ?? undefined,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof WorktreeTeardownError) {
+            dependencies.sessionLogger?.warn({ err: error, targetPath: backing.path, requestId: request.requestId }, "Worktree teardown failed during archive; workspace already archived");
+            return false;
+        }
+        throw error;
+    }
+    const remainingActive = await dependencies.listActiveWorkspaces();
+    if (!(await isDirectoryUnreferenced(remainingActive, backing.path, new Set(archivedWorkspaceIds), dependencies))) {
+        return false;
+    }
+    try {
+        await deletePaseoWorktree({
+            cwd: backing.mainRepoRoot,
+            worktreePath: backing.path,
+            teardownCwds: [],
+            worktreesRoot: backing.paseoWorktreesRoot ?? undefined,
+            paseoHome: dependencies.paseoHome,
+            worktreesBaseRoot: dependencies.paseoWorktreesBaseRoot,
+        });
+        dependencies.github.invalidate({ cwd: backing.path });
+        return true;
+    }
+    catch (error) {
+        dependencies.sessionLogger?.warn({ err: error, targetPath: backing.path, requestId: request.requestId }, "Worktree disk removal failed during archive; workspace already archived");
+        return false;
+    }
+}
+async function filterAllowedTeardownTargets(dependencies, targets) {
+    const allowed = [];
+    const blockedCwds = [];
+    for (const target of targets) {
+        try {
+            if (target.workspaceId)
+                await dependencies.assertWorkspaceAutomationAllowed?.(target.workspaceId);
+            allowed.push(target);
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceAutomationBlockedError))
+                throw error;
+            blockedCwds.push(target.cwd);
+        }
+    }
+    return allowed.filter((target) => !blockedCwds.some((cwd) => createRealpathAwarePathMatcher(cwd)(target.cwd)));
+}
+function uniqueTeardownTargets(targets) {
+    const unique = [];
+    for (const candidate of targets) {
+        if (!unique.some((existing) => createRealpathAwarePathMatcher(existing.cwd)(candidate.cwd))) {
+            unique.push(candidate);
+        }
+    }
+    return unique;
+}
+// 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.listByWorkspace(workspaceId);
+    }
+    catch (error) {
+        dependencies.sessionLogger?.warn({ err: error, workspaceId }, "Failed to list stored agents during workspace archive; continuing");
+    }
+    const matchingStoredRecords = storedRecords;
+    for (const record of matchingStoredRecords) {
+        archivedAgents.add(record.id);
+    }
+    const archivedAt = new Date().toISOString();
+    const agentIdsToArchive = new Set([
+        ...liveAgents.map((agent) => agent.id),
+        ...matchingStoredRecords.filter((record) => !record.archivedAt).map((record) => record.id),
+    ]);
+    const archiveResults = await Promise.allSettled([
+        ...[...agentIdsToArchive].map((agentId) => dependencies.agentManager.getAgent(agentId)
+            ? dependencies.agentManager.archiveAgent(agentId)
+            : dependencies.agentManager.archiveSnapshot(agentId, 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;
+}
+// True when, after archiving
+// the in-scope records, no active workspace still points at targetDir. Derived
+// from records each call — no stored counter.
+async function isDirectoryUnreferenced(activeWorkspaces, targetDir, archivedWorkspaceIds, dependencies) {
+    const target = resolve(targetDir);
+    const matchesTarget = createRealpathAwarePathMatcher(target);
+    for (const workspace of activeWorkspaces) {
+        if (archivedWorkspaceIds.has(workspace.workspaceId))
+            continue;
+        const backingDirectory = await resolveWorkspaceBackingDirectory(workspace, dependencies);
+        if (matchesTarget(backingDirectory.path))
+            return false;
+    }
+    return true;
+}
+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, input.context);
+    return existingWorkspace;
+}
+//# sourceMappingURL=workspace-archive-service.js.map

package/dist/server/server/workspace-auto-name.d.ts

@@ -0,0 +1,55 @@
+import type pino from "pino";
+import type { FirstAgentContext } from "@camerontaylor/paseo-protocol/messages";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { StructuredGenerationDaemonConfig } from "./agent/structured-generation-providers.js";
+import type { GitMutationService } from "./session/git-mutation/git-mutation-service.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { PersistedWorkspaceRecord, WorkspaceRegistry } from "./workspace-registry.js";
+import { generateBranchNameFromFirstAgentContext, type GenerateBranchNameFromFirstAgentContextOptions } from "./worktree-branch-name-generator.js";
+type WorkspaceNameGenerator = typeof generateBranchNameFromFirstAgentContext;
+type CurrentSelection = GenerateBranchNameFromFirstAgentContextOptions["currentSelection"] | null;
+interface WorkspaceAutoNameOptions {
+    agentManager: AgentManager;
+    workspaceRegistry: Pick<WorkspaceRegistry, "update">;
+    workspaceGitService: WorkspaceGitService;
+    providerSnapshotManager: ProviderSnapshotManager;
+    readDaemonConfig: () => StructuredGenerationDaemonConfig;
+    gitMutation: Pick<GitMutationService, "notifyGitMutation">;
+    emitWorkspaceUpdateForCwd: (cwd: string) => Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId: (workspaceId: string) => Promise<void>;
+    logger: pino.Logger;
+    generateWorkspaceName?: WorkspaceNameGenerator;
+}
+interface ScheduleContext {
+    currentSelection?: CurrentSelection;
+}
+export declare class WorkspaceAutoName {
+    private readonly agentManager;
+    private readonly workspaceRegistry;
+    private readonly workspaceGitService;
+    private readonly providerSnapshotManager;
+    private readonly readDaemonConfig;
+    private readonly gitMutation;
+    private readonly emitWorkspaceUpdateForCwd;
+    private readonly emitWorkspaceUpdateForWorkspaceId;
+    private readonly logger;
+    private readonly generateWorkspaceName;
+    constructor(options: WorkspaceAutoNameOptions);
+    scheduleForWorktree(input: {
+        workspace: PersistedWorkspaceRecord;
+        firstAgentContext: FirstAgentContext;
+    }, context?: ScheduleContext): void;
+    scheduleForDirectory(input: {
+        workspaceId: string;
+        cwd: string;
+        firstAgentContext: FirstAgentContext;
+    }, context?: ScheduleContext): void;
+    private maybeAutoNameWorkspaceBranchForFirstAgent;
+    private maybeAutoNameDirectoryWorkspaceTitle;
+    private applyGeneratedWorkspaceTitle;
+    private generateFromContext;
+    private schedule;
+}
+export {};
+//# sourceMappingURL=workspace-auto-name.d.ts.map

package/dist/server/server/workspace-auto-name.js

@@ -0,0 +1,127 @@
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
+import { attemptFirstAgentBranchAutoName, } from "./paseo-worktree-service.js";
+import { generateBranchNameFromFirstAgentContext, } from "./worktree-branch-name-generator.js";
+export class WorkspaceAutoName {
+    constructor(options) {
+        this.agentManager = options.agentManager;
+        this.workspaceRegistry = options.workspaceRegistry;
+        this.workspaceGitService = options.workspaceGitService;
+        this.providerSnapshotManager = options.providerSnapshotManager;
+        this.readDaemonConfig = options.readDaemonConfig;
+        this.gitMutation = options.gitMutation;
+        this.emitWorkspaceUpdateForCwd = options.emitWorkspaceUpdateForCwd;
+        this.emitWorkspaceUpdateForWorkspaceId = options.emitWorkspaceUpdateForWorkspaceId;
+        this.logger = options.logger;
+        this.generateWorkspaceName =
+            options.generateWorkspaceName ?? generateBranchNameFromFirstAgentContext;
+    }
+    scheduleForWorktree(input, context = {}) {
+        this.schedule(() => this.maybeAutoNameWorkspaceBranchForFirstAgent({
+            ...input,
+            currentSelection: context.currentSelection ?? null,
+        }), {
+            cwd: input.workspace.cwd,
+            message: "Failed to auto-name worktree branch",
+        });
+    }
+    scheduleForDirectory(input, context = {}) {
+        this.schedule(() => this.maybeAutoNameDirectoryWorkspaceTitle({
+            ...input,
+            currentSelection: context.currentSelection ?? null,
+        }), { cwd: input.cwd, message: "Failed to auto-name directory workspace title" });
+    }
+    async maybeAutoNameWorkspaceBranchForFirstAgent(input) {
+        const worktreeRoot = input.workspace.worktreeRoot ?? input.workspace.cwd;
+        let generated = null;
+        const result = await attemptFirstAgentBranchAutoName({
+            cwd: worktreeRoot,
+            firstAgentContext: input.firstAgentContext,
+            generateBranchNameFromContext: ({ firstAgentContext }) => {
+                return this.generateFromContext({
+                    cwd: input.workspace.cwd,
+                    firstAgentContext,
+                    currentSelection: input.currentSelection,
+                }).then((nextGenerated) => {
+                    generated = nextGenerated;
+                    return nextGenerated?.branch ?? null;
+                });
+            },
+        });
+        if (!generated) {
+            generated = await this.generateFromContext({
+                cwd: input.workspace.cwd,
+                firstAgentContext: input.firstAgentContext,
+                currentSelection: input.currentSelection,
+            });
+        }
+        const generatedTitle = generated?.title ?? null;
+        if (!generatedTitle) {
+            return;
+        }
+        // K4: re-read from the registry before writing so any concurrent upsert
+        // that happened between workspace creation and this async path is not clobbered.
+        // When the first-agent rename changed the git branch too, persist that branch
+        // alongside the title — both are this path's own fields.
+        await this.applyGeneratedWorkspaceTitle(input.workspace.workspaceId, {
+            title: generatedTitle,
+            ...(result.renamed ? { branch: result.branchName } : {}),
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        });
+        if (result.renamed) {
+            await this.gitMutation.notifyGitMutation(worktreeRoot, "rename-branch");
+        }
+        await this.emitWorkspaceUpdateForCwd(input.workspace.cwd);
+    }
+    async maybeAutoNameDirectoryWorkspaceTitle(input) {
+        const generated = await this.generateFromContext({
+            cwd: input.cwd,
+            firstAgentContext: input.firstAgentContext,
+            currentSelection: input.currentSelection,
+        });
+        const title = generated?.title ?? null;
+        if (!title) {
+            return;
+        }
+        // K4: applyGeneratedWorkspaceTitle re-reads from the registry before writing.
+        // Directory workspaces have no branch — write only the title.
+        await this.applyGeneratedWorkspaceTitle(input.workspaceId, {
+            title,
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        });
+        await this.emitWorkspaceUpdateForWorkspaceId(input.workspaceId);
+    }
+    async applyGeneratedWorkspaceTitle(workspaceId, input) {
+        await this.workspaceRegistry.update(workspaceId, (current) => {
+            let title = current.title;
+            if (!title || (input.promptTitle && title === input.promptTitle)) {
+                title = input.title;
+            }
+            return {
+                ...current,
+                title,
+                ...(input.branch ? { branch: input.branch } : {}),
+                updatedAt: new Date().toISOString(),
+            };
+        });
+    }
+    generateFromContext(input) {
+        return this.generateWorkspaceName({
+            agentManager: this.agentManager,
+            cwd: input.cwd,
+            workspaceGitService: this.workspaceGitService,
+            providerSnapshotManager: this.providerSnapshotManager,
+            daemonConfig: this.readDaemonConfig(),
+            currentSelection: input.currentSelection ?? undefined,
+            firstAgentContext: input.firstAgentContext,
+            logger: this.logger,
+        });
+    }
+    schedule(run, context) {
+        setTimeout(() => {
+            void run().catch((error) => {
+                this.logger.warn({ err: error, cwd: context.cwd }, context.message);
+            });
+        }, 0);
+    }
+}
+//# sourceMappingURL=workspace-auto-name.js.map

package/dist/server/server/workspace-automation-gate.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceRegistry } from "./workspace-registry.js";
+export interface UntrustedWorkspaceSource {
+    kind: "change_request";
+    forge: string;
+    number: number;
+    headRepository: string;
+}
+export declare function formatWorkspaceAutomationBlockedMessage(source: UntrustedWorkspaceSource): string;
+export declare class WorkspaceAutomationBlockedError extends Error {
+    readonly source: UntrustedWorkspaceSource;
+    constructor(source: UntrustedWorkspaceSource);
+}
+export declare function assertWorkspaceAutomationAllowed(source: UntrustedWorkspaceSource | undefined): void;
+export declare function assertWorkspaceAutomationAllowedForWorkspace(registry: Pick<WorkspaceRegistry, "get">, workspaceId: string): Promise<void>;
+export declare function clearWorkspaceAutomationBlock(registry: Pick<WorkspaceRegistry, "update">, workspaceId: string): Promise<boolean>;
+//# sourceMappingURL=workspace-automation-gate.d.ts.map

package/dist/server/server/workspace-automation-gate.js

@@ -0,0 +1,35 @@
+export function formatWorkspaceAutomationBlockedMessage(source) {
+    const changeRequestNoun = source.forge === "gitlab" ? "MR" : "PR";
+    return `Scripts are blocked for ${changeRequestNoun} #${source.number} from ${source.headRepository}. Run setup to allow them.`;
+}
+export class WorkspaceAutomationBlockedError extends Error {
+    constructor(source) {
+        super(formatWorkspaceAutomationBlockedMessage(source));
+        this.source = source;
+        this.name = "WorkspaceAutomationBlockedError";
+    }
+}
+export function assertWorkspaceAutomationAllowed(source) {
+    if (source)
+        throw new WorkspaceAutomationBlockedError(source);
+}
+export async function assertWorkspaceAutomationAllowedForWorkspace(registry, workspaceId) {
+    const workspace = await registry.get(workspaceId);
+    if (!workspace)
+        throw new Error(`Workspace not found: ${workspaceId}`);
+    assertWorkspaceAutomationAllowed(workspace.untrustedSource);
+}
+export async function clearWorkspaceAutomationBlock(registry, workspaceId) {
+    let cleared = false;
+    const workspace = await registry.update(workspaceId, (record) => {
+        if (!record.untrustedSource)
+            return record;
+        cleared = true;
+        const { untrustedSource: _removed, ...trusted } = record;
+        return { ...trusted, updatedAt: new Date().toISOString() };
+    });
+    if (!workspace)
+        throw new Error(`Workspace not found: ${workspaceId}`);
+    return cleared;
+}
+//# sourceMappingURL=workspace-automation-gate.js.map