@gtc6244/immediacy-daemon 0.1.0

package/dist/src/workspace.js

@@ -0,0 +1,1086 @@
+/**
+ * WorkspaceManager — owns the set of workspaces and, per workspace, its
+ * worktree, agent, and terminal. Translates agent events into broadcast wire
+ * messages and persists metadata so sessions survive a daemon restart (resume).
+ */
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { ChatLog } from "./chatlog.js";
+import { formatTurnUsage } from "./usage.js";
+import { ProjectStore } from "./projects.js";
+import { AppConfigStore } from "./config.js";
+import { CredentialsStore } from "./credentials.js";
+import { AllowlistStore } from "./allowlist.js";
+import { MockAgent } from "./agent/mock.js";
+import { ClaudeAgent } from "./agent/claude.js";
+import { CodexAgent } from "./agent/codex.js";
+import { OpenRouterAgent } from "./agent/openrouter.js";
+import { providerFor } from "./models.js";
+import { Terminal } from "./terminal.js";
+import { createWorktree, createWorktreeFromExistingBranch, createWorktreeFromPr, listBranches, removeWorktree, deleteLocalBranch, currentBranch, diffWorktree, diffStat, ensureCleanWorktree, listTree, readWorktreeFile, writeWorktreeFile, } from "./worktree.js";
+import { gitStatus, gitCommit, gitPush, gitResolve, gitMerge, prCreate, prMerge, detectMerged, prInfo, openWorktree, originUrl } from "./gitops.js";
+import { maybeSyncRepo } from "./repo-sync.js";
+import { listPullRequests, prHeadRef, listIssues, createIssue } from "./github.js";
+import { composeActionPrompt } from "./actions.js";
+import { generateChatTitle } from "./titler.js";
+const STATE_FILE = process.env.STATE_FILE ?? join(homedir(), ".immediacy", "state.json");
+/** Root for repo-less chat workspaces' scratch dirs (one per chat). */
+const CHATS_DIR = process.env.CHATS_DIR ?? join(homedir(), ".immediacy", "chats");
+const AGENT_MODE = (process.env.AGENT_MODE ?? "claude").toLowerCase();
+/**
+ * The sidebar-label form of a branch/ref: drops a leading owner/account segment
+ * so the label reads as the work, not who pushed it —
+ * `"Brutus-GTC6245/amman"` → `"amman"`. Only the first segment (the account) is
+ * removed; any deeper path is kept, and a ref with no `/` is returned unchanged.
+ */
+function branchLabel(ref) {
+    const i = ref.indexOf("/");
+    const label = i >= 0 ? ref.slice(i + 1) : ref;
+    return label || ref;
+}
+export class WorkspaceManager {
+    hub;
+    chatlog;
+    events;
+    projects;
+    credentials;
+    appConfig;
+    allowlist;
+    workspaces = new Map();
+    /**
+     * The last workspace list we fanned out, JSON-encoded — so
+     * `broadcastWorkspaceList` can no-op when a recompute yields identical rows.
+     */
+    lastListJson = "";
+    constructor(hub, 
+    /** Durable per-workspace transcript, so history survives phone reboots. */
+    chatlog = new ChatLog(), 
+    /**
+     * In-process domain-event bus. Optional so existing callers/tests need no
+     * change; when present, the manager emits at each action chokepoint so the
+     * JobScheduler can drive reactive ("N minutes after X") triggers.
+     */
+    events, 
+    /** Registry of projects worktrees hang under (persisted separately). */
+    projects = new ProjectStore(), 
+    /**
+     * Provider API keys (app-managed, env-seeded). Read at agent-spawn time to
+     * pick a session's credential: a stored/env key, else the CLI/SDK's own SSO
+     * login. Defaulted so existing callers/tests need no change.
+     */
+    credentials = new CredentialsStore(), 
+    /**
+     * Daemon-owned app config (prompts + git behavior). Read live at spawn time
+     * (`prompts.general` → agent system prompt) and at worktree-create time
+     * (`git.branchPrefix*`). Defaulted so existing callers/tests need no change.
+     */
+    appConfig = new AppConfigStore(), 
+    /**
+     * Daemon-global "Allow all" list. Handed to every spawned agent so a prior
+     * grant auto-approves matching calls, and appended to when a client answers
+     * a permission request with `allow_all`. Defaulted for existing callers/tests.
+     */
+    allowlist = new AllowlistStore()) {
+        this.hub = hub;
+        this.chatlog = chatlog;
+        this.events = events;
+        this.projects = projects;
+        this.credentials = credentials;
+        this.appConfig = appConfig;
+        this.allowlist = allowlist;
+    }
+    /** The daemon-global allowlist (for server-side admin: list/revoke/clear). */
+    allowlistStore() {
+        return this.allowlist;
+    }
+    /** Is there a live workspace with this id? (used by the job scheduler). */
+    has(id) {
+        return this.workspaces.has(id);
+    }
+    async load() {
+        await this.chatlog.load();
+        await this.projects.load();
+        let migrated = false;
+        try {
+            const raw = await readFile(STATE_FILE, "utf8");
+            const records = JSON.parse(raw);
+            for (const r of records) {
+                // Worktrees may have been removed out of band; only keep live ones.
+                if (!existsSync(r.worktreePath))
+                    continue;
+                let projectId = r.projectId;
+                // Legacy records (pre-projects) or ones pointing at a since-removed
+                // project get find-or-created a project from their repo so every
+                // worktree still groups under something.
+                if (!projectId || !this.projects.get(projectId)) {
+                    const project = await this.projects.ensureForSource({ repo: r.repo });
+                    projectId = project.id;
+                    migrated = true;
+                }
+                this.workspaces.set(r.id, {
+                    record: { ...r, projectId, status: "idle" },
+                    terminals: new Map(),
+                });
+            }
+            console.log(`[ws] restored ${this.workspaces.size} workspace(s)`);
+        }
+        catch {
+            /* no prior state */
+        }
+        if (migrated)
+            await this.persist();
+    }
+    /** Registered projects (the sidebar groups). */
+    listProjects() {
+        return this.projects.list();
+    }
+    /**
+     * Reorder the registered projects. `ids` is the full list of project ids in
+     * the desired display order (see ProjectStore.reorder for how unknown/missing
+     * ids are handled).
+     */
+    async reorderProjects(ids) {
+        await this.projects.reorder(ids);
+    }
+    /**
+     * Register a project from a blank repo (`git init`), a GitHub source, or an
+     * existing local path. GitHub/local are idempotent (by full name / resolved
+     * path); blank always creates. Does NOT create a worktree — it's a standing
+     * "+ new worktree" target.
+     */
+    async createProject(opts) {
+        return this.projects.ensureForSource(opts);
+    }
+    /**
+     * Branches available to base a new worktree on for a project (local + remote,
+     * deduped). Powers the "create worktree from an existing branch" pickers.
+     */
+    async listBranches(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project)
+            throw new Error(`unknown project: ${projectId}`);
+        const branches = await listBranches(project.repo);
+        return { branches, defaultBranch: project.github?.defaultBranch };
+    }
+    /**
+     * A project's open pull requests, for the "create worktree from an open PR"
+     * picker. Empty when the project has no GitHub remote or `gh` isn't available.
+     */
+    async listPullRequests(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project)
+            throw new Error(`unknown project: ${projectId}`);
+        return listPullRequests(project.repo);
+    }
+    /**
+     * A project's open issues (with bodies), for the "create worktree from an
+     * issue" picker + confirm step. Empty when there's no GitHub remote / gh.
+     */
+    async listIssues(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project)
+            throw new Error(`unknown project: ${projectId}`);
+        return listIssues(project.repo);
+    }
+    /** Remove a project. Rejected while any worktree still references it. */
+    async deleteProject(id) {
+        const inUse = [...this.workspaces.values()].some((l) => l.record.projectId === id);
+        if (inUse) {
+            throw new Error("project still has worktrees; remove them first");
+        }
+        await this.projects.remove(id);
+    }
+    /** Persisted transcript for a workspace (chronological). */
+    history(id) {
+        return this.chatlog.entries(id);
+    }
+    async persist() {
+        await mkdir(dirname(STATE_FILE), { recursive: true });
+        const records = [...this.workspaces.values()].map((l) => l.record);
+        await writeFile(STATE_FILE, JSON.stringify(records, null, 2), "utf8");
+    }
+    list() {
+        return [...this.workspaces.values()].map((l) => l.record);
+    }
+    /**
+     * Create a workspace (worktree) under a project. Preferred: pass `projectId`.
+     * The legacy path — a bare `repo`/`github` with no projectId — find-or-creates
+     * the matching project first, so every worktree ends up grouped.
+     */
+    async create(opts) {
+        // Resolve the owning project: an explicit id, or find-or-create from source.
+        let project;
+        if (opts.projectId) {
+            project = this.projects.get(opts.projectId);
+            if (!project)
+                throw new Error(`unknown project: ${opts.projectId}`);
+        }
+        else {
+            project = await this.projects.ensureForSource({
+                repo: opts.repo,
+                github: opts.github,
+                name: opts.name,
+            });
+        }
+        const repo = project.repo;
+        // GitHub-backed projects branch off the remote default unless overridden.
+        const gh = opts.github ?? project.github;
+        const branchBase = opts.branchBase ??
+            (gh ? `origin/${gh.defaultBranch ?? "HEAD"}` : undefined);
+        const id = randomUUID();
+        const sourceBranch = opts.sourceBranch?.trim();
+        const sourcePr = opts.sourcePr;
+        // Resolve the PR's head branch up front so it can also seed the workspace
+        // name (a meaningful label) and drive the checkout below.
+        const prHead = sourcePr ? await prHeadRef(repo, sourcePr) : undefined;
+        // When basing off an existing branch or PR, default the workspace name to
+        // that branch (a meaningful label), minus any owner/account prefix
+        // (branchLabel: "Brutus-GTC6245/amman" → "amman"); otherwise fall back to a
+        // short id. An explicit name from the client wins untouched.
+        const wsName = opts.name?.trim() ||
+            (sourceBranch && branchLabel(sourceBranch)) ||
+            (prHead && branchLabel(prHead)) ||
+            `ws-${id.slice(0, 6)}`;
+        const gitCfg = this.appConfig.get().git;
+        // Three shapes: check out an existing PR's head branch, check out an existing
+        // branch, or fork a fresh one off the base.
+        const wt = prHead
+            ? await createWorktreeFromPr(repo, id, sourcePr, prHead, branchBase)
+            : sourceBranch
+                ? await createWorktreeFromExistingBranch(repo, id, sourceBranch, branchBase)
+                : await createWorktree(repo, id, wsName, branchBase, {
+                    type: gitCfg.branchPrefixType,
+                    custom: gitCfg.branchPrefix,
+                });
+        const record = {
+            id,
+            name: wsName,
+            projectId: project.id,
+            repo,
+            worktreePath: wt.worktreePath,
+            branch: wt.branch,
+            baseBranch: wt.baseBranch,
+            status: "idle",
+            model: opts.model,
+        };
+        this.workspaces.set(id, { record, terminals: new Map() });
+        await this.persist();
+        this.hub.broadcast("workspace.created", id, {
+            ws: id,
+            name: wsName,
+            branch: wt.branch,
+        });
+        this.events?.emitSystem({ kind: "workspace.created", ws: id, context: { name: wsName } });
+        // "Create worktree from an issue": kick the agent off with the confirmed
+        // issue as its first task, now that the worktree exists.
+        const initialPrompt = opts.initialPrompt?.trim();
+        if (initialPrompt)
+            this.prompt(id, initialPrompt);
+        return record;
+    }
+    /**
+     * Create a repo-less "chat" workspace — a free-form conversation with the
+     * agent, not tied to any GitHub project or git worktree (the Claude/ChatGPT
+     * desktop model). It starts named "New Chat"; the first prompt triggers an
+     * auto-title (see `prompt`). The agent still gets a real cwd — a private
+     * scratch dir under `~/.immediacy/chats/<id>` — so file/bash tools work,
+     * scoped to that folder by the usual workspace-scope rule.
+     */
+    async createChat(opts = {}) {
+        const id = randomUUID();
+        const scratch = join(CHATS_DIR, id);
+        await mkdir(scratch, { recursive: true });
+        const record = {
+            id,
+            name: "New Chat",
+            kind: "chat",
+            projectId: "",
+            repo: scratch,
+            worktreePath: scratch,
+            branch: "",
+            baseBranch: "",
+            status: "idle",
+            model: opts.model,
+        };
+        this.workspaces.set(id, { record, terminals: new Map() });
+        await this.persist();
+        this.hub.broadcast("workspace.created", id, {
+            ws: id,
+            name: record.name,
+            branch: "",
+            kind: "chat",
+        });
+        this.events?.emitSystem({ kind: "workspace.created", ws: id, context: { name: record.name } });
+        return record;
+    }
+    /**
+     * Rename a workspace and fan the new label out to every client. Used by the
+     * chat auto-title flow; the sidebar row updates in place without a full list
+     * refresh.
+     */
+    async renameWorkspace(id, name) {
+        const live = this.workspaces.get(id);
+        if (!live || !name.trim())
+            return;
+        live.record.name = name.trim();
+        await this.persist();
+        this.hub.broadcast("workspace.renamed", id, { ws: id, name: live.record.name });
+    }
+    /**
+     * Summarize a chat's first prompt into a short title and rename the workspace.
+     * Fire-and-forget: guards against a racing second prompt (only renames while
+     * the label is still the placeholder) and swallows any failure.
+     */
+    async autoTitleChat(id, firstPrompt) {
+        const sdkEnv = envForKey("ANTHROPIC_API_KEY", this.credentials.getKey("anthropic"));
+        const title = await generateChatTitle(firstPrompt, sdkEnv);
+        if (!title)
+            return;
+        const live = this.workspaces.get(id);
+        // Re-check: the user (or a prior title) may have renamed it meanwhile.
+        if (!live || live.record.kind !== "chat" || live.record.name !== "New Chat")
+            return;
+        await this.renameWorkspace(id, title);
+    }
+    /** Added/removed line totals vs base, per workspace (for the sidebar rows). */
+    async diffStat(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        if (live.record.kind === "chat")
+            return { added: 0, removed: 0, filesChanged: 0 };
+        // Freshen origin first: the stat is measured against merge-base(origin/<base>,
+        // HEAD), so a stale remote-tracking ref regresses that merge-base and inflates
+        // the counts by sweeping in commits the branch only merged, not authored (the
+        // +2.7k-vs-+425 drift). Throttled + coalesced per repo, so it's a no-op when a
+        // recent poll already fetched. See diffBaseRef in worktree.ts.
+        await maybeSyncRepo(live.record.repo);
+        return diffStat(live.record.worktreePath, live.record.baseBranch);
+    }
+    /**
+     * The sidebar summaries: one row per workspace with its live diff-stat. Diffs
+     * are measured in parallel and best-effort (0/0 on any git hiccup); `added`/
+     * `removed` are omitted when zero so a clean worktree renders no counter.
+     */
+    async summaries() {
+        const list = this.list();
+        // Same freshness requirement as diffStat/diff: the per-row counts are diffed
+        // against merge-base(origin/<base>, HEAD), so a stale origin inflates them.
+        // Freshen each distinct base repo before measuring — throttled + coalesced per
+        // repo, so a workspace-heavy account still costs at most one fetch per repo per
+        // interval, and it's a no-op when a recent poll already fetched.
+        // Chats have no git repo — only freshen the worktree-backed ones.
+        await Promise.all([...new Set(list.filter((r) => r.kind !== "chat").map((r) => r.repo))].map((repo) => maybeSyncRepo(repo)));
+        return Promise.all(list.map(async (r) => {
+            // A chat has no diff or origin — emit a bare row carrying only its kind.
+            if (r.kind === "chat") {
+                return {
+                    ws: r.id,
+                    name: r.name,
+                    branch: r.branch,
+                    status: r.status,
+                    projectId: r.projectId,
+                    kind: "chat",
+                    ...(r.model ? { model: r.model } : {}),
+                };
+            }
+            const stat = (await diffStat(r.worktreePath, r.baseBranch)) ??
+                { added: 0, removed: 0, filesChanged: 0 };
+            const repoUrl = await originUrl(r.repo);
+            return {
+                ws: r.id,
+                name: r.name,
+                branch: r.branch,
+                status: r.status,
+                projectId: r.projectId,
+                model: r.model,
+                ...(stat.added ? { added: stat.added } : {}),
+                ...(stat.removed ? { removed: stat.removed } : {}),
+                ...(stat.filesChanged ? { filesChanged: stat.filesChanged } : {}),
+                ...(repoUrl ? { repoUrl } : {}),
+            };
+        }));
+    }
+    /**
+     * Recompute the sidebar summaries and fan them out to every client — but only
+     * when something actually changed since the last fan-out. This is the single
+     * entry point for keeping the left-pane rows (diff-stat counters, name,
+     * branch, status) live: callers fire it whenever a worktree's state may have
+     * moved (an agent turn finished, files changed, the base advanced, a branch or
+     * PR was renamed) without having to know whether the numbers really shifted.
+     * The change-check keeps a frequently-polled path (git.status) from spamming
+     * identical lists at every connected device.
+     */
+    async broadcastWorkspaceList() {
+        const list = await this.summaries();
+        const json = JSON.stringify(list);
+        if (json === this.lastListJson)
+            return; // nothing moved — skip the fan-out
+        this.lastListJson = json;
+        this.hub.broadcast("workspace.list.result", null, { workspaces: list });
+    }
+    /**
+     * Freshen every base repo's remote-tracking refs, then reconcile the sidebar.
+     * This is the "an app just (re)connected — make the left pane reflect GitHub,
+     * not a snapshot from whenever we last fetched" path: the client's first
+     * `workspace.list` gets an immediate (locally-computed) reply for a snappy
+     * paint, and this runs alongside it so a since-pushed base lands a moment
+     * later. One fetch per distinct repo, throttled + coalesced per repo (see
+     * maybeSyncRepo), so a workspace-heavy account still costs one fetch per repo
+     * per interval; the broadcast's change-check no-ops when nothing moved.
+     * Best-effort — an offline/no-remote repo keeps its last-known refs.
+     */
+    async syncAllReposAndRefresh() {
+        const repos = new Set(this.list().map((r) => r.repo));
+        await Promise.all([...repos].map((repo) => maybeSyncRepo(repo)));
+        await this.broadcastWorkspaceList();
+    }
+    async delete(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return;
+        // A chat has no worktree/branch to preserve — tear down its scratch dir.
+        if (live.record.kind === "chat") {
+            await this.deleteChat(live);
+            return;
+        }
+        await ensureCleanWorktree(live.record.worktreePath);
+        await live.agent?.stop();
+        for (const dt of live.terminals.values())
+            dt.terminal?.dispose();
+        // Soft delete: remove the worktree, keep the branch + base repo (§11).
+        await removeWorktree(live.record.repo, live.record.worktreePath);
+        this.workspaces.delete(id);
+        await this.chatlog.remove(id);
+        await this.persist();
+    }
+    /** Tear down a repo-less chat: stop the agent, drop its scratch dir + log. */
+    async deleteChat(live) {
+        const id = live.record.id;
+        await live.agent?.stop();
+        for (const dt of live.terminals.values())
+            dt.terminal?.dispose();
+        await rm(live.record.worktreePath, { recursive: true, force: true }).catch(() => { });
+        this.workspaces.delete(id);
+        await this.chatlog.remove(id);
+        await this.persist();
+    }
+    /**
+     * Archive a workspace: a deliberate teardown that force-removes the worktree
+     * (discarding any uncommitted changes) and — only when
+     * git.deleteBranchOnArchive is set — deletes the *local* branch. The remote
+     * (pushed branch, PR, commits on origin) is never touched, so archiving a
+     * merged workspace is non-destructive to the shipped work. Distinct from
+     * delete, which always preserves the branch (§11).
+     */
+    async archive(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return;
+        // A chat has no worktree/branch — archive is the same teardown as delete.
+        if (live.record.kind === "chat") {
+            await this.deleteChat(live);
+            return;
+        }
+        const { repo, worktreePath, branch } = live.record;
+        await live.agent?.stop();
+        for (const dt of live.terminals.values())
+            dt.terminal?.dispose();
+        await removeWorktree(repo, worktreePath, /* force */ true);
+        if (this.appConfig.get().git.deleteBranchOnArchive) {
+            await deleteLocalBranch(repo, branch);
+        }
+        this.workspaces.delete(id);
+        await this.chatlog.remove(id);
+        await this.persist();
+    }
+    /**
+     * Run a prompt-backed agent action (code review, create PR, fix errors,
+     * resolve merge conflicts, rename branch). Composes the built-in instruction
+     * plus the user's matching prompts.* custom text, then injects it through the
+     * normal prompt path — the agent does the work with its own permission-gated
+     * tools. Returns false when the workspace is unknown.
+     */
+    runAction(id, kind) {
+        if (!this.workspaces.has(id))
+            return false;
+        this.prompt(id, composeActionPrompt(kind, this.appConfig.get().prompts));
+        return true;
+    }
+    /**
+     * Mass-delete worktrees and/or whole projects. Selected projects contribute
+     * all of their remaining worktrees to the removal set (a project can't be
+     * deleted while any worktree still references it), then the projects
+     * themselves are removed. Each item is attempted independently: a dirty
+     * worktree that refuses removal is collected as a failure rather than
+     * aborting the rest — and its owning project then fails too (correctly, since
+     * it still has a worktree). Callers broadcast fresh lists afterwards.
+     */
+    async deleteBatch(opts) {
+        const projectIds = new Set(opts.projects ?? []);
+        const wsIds = new Set(opts.workspaces ?? []);
+        // Fold in every worktree owned by a selected project.
+        for (const live of this.workspaces.values()) {
+            if (projectIds.has(live.record.projectId))
+                wsIds.add(live.record.id);
+        }
+        const deletedWorkspaces = [];
+        const deletedProjects = [];
+        const failures = [];
+        for (const id of wsIds) {
+            // Unknown/stale id (e.g. removed by another device between list and
+            // batch): skip it rather than report a phantom removal — delete() itself
+            // would no-op silently and we'd falsely count it as deleted.
+            if (!this.workspaces.has(id))
+                continue;
+            try {
+                await this.delete(id);
+                deletedWorkspaces.push(id);
+            }
+            catch (err) {
+                failures.push({ id, kind: "workspace", message: errText(err) });
+            }
+        }
+        // Projects last: their worktrees are gone (or failed, which will surface
+        // here as a "still has worktrees" project failure).
+        for (const id of projectIds) {
+            if (!this.projects.get(id))
+                continue; // unknown/stale project id: skip
+            try {
+                await this.deleteProject(id);
+                deletedProjects.push(id);
+            }
+            catch (err) {
+                failures.push({ id, kind: "project", message: errText(err) });
+            }
+        }
+        return { deletedWorkspaces, deletedProjects, failures };
+    }
+    prompt(id, text, attachments) {
+        const live = this.workspaces.get(id);
+        if (!live) {
+            this.hub.broadcast("error", id, { code: "no_such_ws", message: "unknown workspace", ws: id });
+            return;
+        }
+        if (!live.agent)
+            live.agent = this.spawnAgent(live);
+        // A fresh chat is "New Chat" until its first prompt; summarize that prompt
+        // into a short label (one cheap LLM call, best-effort, non-blocking).
+        if (live.record.kind === "chat" && live.record.name === "New Chat" && text.trim()) {
+            void this.autoTitleChat(id, text);
+        }
+        // Persist only attachment metadata (name + type) — never the bytes — so the
+        // transcript stays small and replay shows a chip without re-shipping files.
+        const attachmentMeta = attachments?.length
+            ? attachments.map((a) => ({ name: a.name, mediaType: a.mediaType }))
+            : undefined;
+        void this.chatlog.append(id, {
+            ts: Date.now(),
+            role: "user",
+            text,
+            ...(attachmentMeta ? { attachments: attachmentMeta } : {}),
+        });
+        // The workspace is working the moment we hand off the prompt. Publish
+        // `running` now — the agent only emits its own `running` once at spawn, so a
+        // resumed turn would otherwise stay stale at the previous turn's `done`
+        // until its first streamed chunk, leaving the client's working timer/badge
+        // dark until the first response lands.
+        this.setStatus(live, "running");
+        live.agent.prompt(text, attachments);
+    }
+    /**
+     * Interrupt the running agent turn. The session itself survives (its id is
+     * persisted), so the next prompt resumes the conversation in a fresh agent.
+     */
+    async stopAgent(id) {
+        const live = this.workspaces.get(id);
+        if (!live?.agent)
+            return;
+        const agent = live.agent;
+        live.agent = undefined;
+        await agent.stop();
+        void this.chatlog.append(id, { ts: Date.now(), role: "system", text: "■ stopped" });
+        this.setStatus(live, "idle");
+    }
+    respondPermission(id, requestId, decision) {
+        this.workspaces.get(id)?.agent?.respondPermission(requestId, decision);
+        // The transcript records only the effect (allow_all lands as an allow); the
+        // durable rule itself lives in the allowlist store, not the chat log.
+        const resolved = decision === "deny" ? "deny" : "allow";
+        void this.chatlog.resolvePermission(id, requestId, resolved);
+    }
+    answerQuestion(id, requestId, answers, response) {
+        this.workspaces.get(id)?.agent?.answerQuestion(requestId, answers, response);
+        void this.chatlog.resolveQuestion(id, requestId, answers, response);
+    }
+    async diff(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        if (live.record.kind === "chat")
+            return [];
+        // Freshen origin first, for the same reason as diffStat: a stale merge-base
+        // makes the file browser show every file the branch merely merged in, not just
+        // what it changed. Throttled + coalesced per repo (no-op right after a poll).
+        await maybeSyncRepo(live.record.repo);
+        return diffWorktree(live.record.worktreePath, live.record.baseBranch);
+    }
+    /** Full-codebase file listing for a workspace. */
+    async tree(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return listTree(live.record.worktreePath);
+    }
+    /** Read one worktree-relative file (for the in-app viewer). */
+    async readFile(id, path) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return readWorktreeFile(live.record.worktreePath, path);
+    }
+    /** Overwrite one worktree file (in-app editor save). Returns bytes written, or null for an unknown workspace. */
+    async writeFile(id, path, content) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return writeWorktreeFile(live.record.worktreePath, path, content);
+    }
+    /** Get (or create) a device's terminal slot, re-binding it to `socket`. */
+    deviceTerm(live, deviceId, socket) {
+        const dt = live.terminals.get(deviceId);
+        if (dt) {
+            // A reconnect (or just a fresh interaction) points the stream at the
+            // device's current socket so output follows it across reconnects.
+            dt.socket = socket;
+            return dt;
+        }
+        const fresh = { socket };
+        live.terminals.set(deviceId, fresh);
+        return fresh;
+    }
+    /**
+     * Dispose any terminal keyed by `deviceId` across every workspace. Called when
+     * a socket closes, passing that connection's fallback `connId`: a client that
+     * sends no stable deviceId gets a fresh connId per connection, so without this
+     * its PTY would leak on every reconnect. Terminals under a *stable* deviceId
+     * are intentionally left intact so their scrollback survives a reconnect.
+     */
+    reapDevice(deviceId) {
+        for (const live of this.workspaces.values()) {
+            const dt = live.terminals.get(deviceId);
+            if (!dt)
+                continue;
+            dt.terminal?.dispose();
+            live.terminals.delete(deviceId);
+        }
+    }
+    terminalInput(id, deviceId, data, socket) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return;
+        const dt = this.deviceTerm(live, deviceId, socket);
+        if (!dt.terminal || dt.terminal.isExited) {
+            dt.terminal = new Terminal(live.record.worktreePath, 
+            // Stream ONLY to this device's socket — not a broadcast — so each
+            // device sees its own pty at its own size.
+            (d) => this.hub.sendTo(dt.socket, "terminal.data", id, { ws: id, data: d }), {
+                ...dt.pendingSize,
+                // On shell exit, drop the dead PTY so the next keystroke respawns a
+                // fresh shell instead of writing to a closed process.
+                onExit: () => {
+                    const l = this.workspaces.get(id);
+                    const e = l?.terminals.get(deviceId);
+                    if (e)
+                        e.terminal = undefined;
+                },
+            });
+        }
+        dt.terminal.write(data);
+    }
+    terminalResize(id, deviceId, cols, rows, socket) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return;
+        const dt = this.deviceTerm(live, deviceId, socket);
+        // Remember the geometry even if the shell hasn't spawned yet, so the PTY
+        // comes up at the right size on first keystroke rather than 80x24. Only
+        // THIS device's pty is resized — a peer with a different screen is untouched.
+        dt.pendingSize = { cols, rows };
+        dt.terminal?.resize(cols, rows);
+    }
+    /** This device's retained PTY scrollback ("" until it has started one). */
+    terminalSnapshot(id, deviceId, socket) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        // Binds the stream to `socket` so live output resumes after a reconnect,
+        // even before the device sends its next keystroke.
+        const dt = this.deviceTerm(live, deviceId, socket);
+        return dt.terminal?.snapshot() ?? "";
+    }
+    async gitStatus(id, sync = false) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        // Chats have no git — no status to report.
+        if (live.record.kind === "chat")
+            return null;
+        // Refresh the base repo's remote-tracking refs before measuring against
+        // them, so ahead/behind and the line counts reflect what's actually on the
+        // remote rather than a snapshot from whenever the repo was last fetched.
+        // Throttled + coalesced per base repo (see maybeSyncRepo): a project with N
+        // worktrees all polling still costs one fetch per interval, not N. `sync` is
+        // set when the client is opening/refreshing the worktree on purpose — it
+        // forces the fetch past the throttle so a just-pushed base is reflected on
+        // the click rather than up to an interval later.
+        await maybeSyncRepo(live.record.repo, { force: sync });
+        // Self-heal: the rename_branch action lets the agent rename its own branch,
+        // which would leave record.branch (used for push/PR) stale. Re-sync from the
+        // worktree's real HEAD on each status poll. When the branch was renamed to
+        // something other than what it was created as, the new name is the
+        // meaningful identity for this work, so track it as the sidebar label too
+        // (the created label was a starting placeholder). broadcastWorkspaceList
+        // below fans the rename out to every client.
+        const cur = await currentBranch(live.record.worktreePath);
+        if (cur && cur !== live.record.branch) {
+            live.record.branch = cur;
+            // Track the label to the branch (minus any owner/account prefix — see
+            // branchLabel) — but not to a bare "HEAD", which is what a detached
+            // checkout (mid-rebase/bisect) reports; that's a transient git state, not a
+            // rename the user should see in the sidebar.
+            if (cur !== "HEAD")
+                live.record.name = branchLabel(cur);
+            await this.persist();
+        }
+        // Auto-archive on merge: when enabled and the branch's PR has merged, tear
+        // the workspace down (honoring deleteBranchOnArchive) and report it gone so
+        // clients drop it. Gated on the flag so the extra `gh` call only runs for
+        // opted-in workspaces. Returns null → the git.status handler re-broadcasts
+        // the workspace list.
+        if (this.appConfig.get().git.archiveOnMerge && (await detectMerged(live.record))) {
+            await this.archive(id);
+            return null;
+        }
+        const result = await gitStatus(live.record);
+        // Always match the label to the remote: once a branch has a PR (open or
+        // merged), that PR's title is the human-facing identity this work lands as,
+        // so adopt it as the sidebar label. This forward-heals a label that was
+        // previously set to the full branch, and keeps a friendly creation name in
+        // sync with the PR the user maintains on GitHub. Reuses the prInfo cache
+        // gitStatus just populated, so it costs no extra `gh` call.
+        if (result.hasPr || result.prMerged) {
+            const pr = await prInfo(live.record);
+            const label = pr.title ? pr.title.trim() : "";
+            if (label && label !== live.record.name) {
+                live.record.name = label;
+                await this.persist();
+            }
+        }
+        // This poll is the client's periodic "is anything new?" — the natural beat
+        // to reconcile the sidebar. It may have just renamed the label (above),
+        // freshened the base (maybeSyncRepo, so a since-landed Resolve/merge moved
+        // the fork point and the line counts with it), or simply be the first poll
+        // after edits that no other path fanned out. Push the fresh rows; the
+        // change-check no-ops when nothing actually moved, so a steady poll on an
+        // untouched worktree stays quiet.
+        void this.broadcastWorkspaceList();
+        return result;
+    }
+    async gitCommit(id, message) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        const result = await gitCommit(live.record, message);
+        if (result.ok)
+            this.events?.emitSystem({ kind: "commit", ws: id });
+        return result;
+    }
+    async gitPush(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        const result = await gitPush(live.record, this.appConfig.get().git.worktreePushAutoSetupRemote);
+        if (result.ok)
+            this.events?.emitSystem({ kind: "push", ws: id });
+        return result;
+    }
+    async gitResolve(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return gitResolve(live.record);
+    }
+    async gitMerge(id, action, paths) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return gitMerge(live.record, action, paths);
+    }
+    async prCreate(id, title, body) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        const result = await prCreate(live.record, title, body);
+        if (result.ok) {
+            // The PR carries the meaningful name for this work — adopt its title as
+            // the sidebar label when it differs from whatever the worktree was created
+            // as, then fan the change out to every client.
+            const prTitle = title.trim();
+            if (prTitle && prTitle !== live.record.name) {
+                live.record.name = prTitle;
+                await this.persist();
+                void this.broadcastWorkspaceList();
+            }
+            this.events?.emitSystem({
+                kind: "pr.created",
+                ws: id,
+                context: result.url ? { url: result.url } : undefined,
+            });
+        }
+        return result;
+    }
+    /** Merge the workspace branch's open PR on the remote (`gh pr merge`). */
+    async prMerge(id) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        return prMerge(live.record);
+    }
+    /**
+     * Open a GitHub issue from a workspace's output — the mirror of `prCreate`.
+     * The result rides the shared `git.result` channel (`op: "issue"`) so clients
+     * reuse their existing PR-create plumbing (busy state, result banner).
+     */
+    async issueCreate(id, title, body) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return null;
+        const ws = live.record.id;
+        const trimmed = title.trim();
+        if (!trimmed) {
+            return { ws, op: "issue", ok: false, message: "issue title is empty" };
+        }
+        try {
+            const url = await createIssue(live.record.worktreePath, trimmed, body ?? "");
+            this.events?.emitSystem({
+                kind: "issue.created",
+                ws: id,
+                context: url ? { url } : undefined,
+            });
+            return { ws, op: "issue", ok: true, message: "issue opened", url };
+        }
+        catch (err) {
+            return {
+                ws,
+                op: "issue",
+                ok: false,
+                message: err instanceof Error ? err.message : "creating issue failed",
+            };
+        }
+    }
+    async open(id, target) {
+        const live = this.workspaces.get(id);
+        if (!live)
+            return;
+        await openWorktree(live.record, target);
+    }
+    // --- internals ---
+    spawnAgent(live) {
+        // prompts.general is appended to every session's system prompt (empty →
+        // omitted, so no-config behavior is unchanged).
+        const general = this.appConfig.get().prompts.general.trim();
+        const ctx = {
+            workspaceId: live.record.id,
+            worktreePath: live.record.worktreePath,
+            resumeSessionId: live.record.sessionId,
+            model: live.record.model,
+            appendSystemPrompt: general || undefined,
+            allowlist: this.allowlist,
+        };
+        // AGENT_MODE=mock forces the scripted backend for every workspace (testing
+        // /CI, no credits). Otherwise the selected model's provider picks the
+        // backend: Claude via the Agent SDK, OpenAI via the Codex CLI, or an
+        // OpenRouter-hosted model via the same Agent SDK pointed at OpenRouter.
+        // Inferred as the union of the concrete classes (all EventEmitters), so
+        // `.on` is available without a cast; the return type narrows to Agent.
+        const provider = providerFor(live.record.model);
+        // Resolve the session's credential from the store (stored key → env → SSO):
+        //  - codex/openai: inject OPENAI_API_KEY when present, else let the Codex CLI
+        //    use its cached ChatGPT login.
+        //  - claude/anthropic: inject ANTHROPIC_API_KEY when present, else let the
+        //    Agent SDK use its cached Claude Code login. (undefined sdkEnv → no
+        //    override, the native SSO path.)
+        //  - openrouter: pass the resolved key straight through (no login fallback).
+        const agent = AGENT_MODE === "mock"
+            ? new MockAgent(ctx)
+            : provider === "codex"
+                ? new CodexAgent(ctx, envForKey("OPENAI_API_KEY", this.credentials.getKey("openai")))
+                : provider === "openrouter"
+                    ? new OpenRouterAgent(ctx, this.credentials.getKey("openrouter"))
+                    : new ClaudeAgent(ctx, envForKey("ANTHROPIC_API_KEY", this.credentials.getKey("anthropic")));
+        agent.on("event", (e) => this.onAgentEvent(live, e));
+        return agent;
+    }
+    onAgentEvent(live, e) {
+        const id = live.record.id;
+        switch (e.kind) {
+            case "assistant":
+                this.hub.broadcast("event.assistant_message", id, { ws: id, text: e.text });
+                void this.chatlog.append(id, { ts: Date.now(), role: "assistant", text: e.text });
+                break;
+            case "tool_use":
+                this.hub.broadcast("event.tool_use", id, {
+                    ws: id,
+                    tool: e.tool,
+                    inputSummary: e.inputSummary,
+                });
+                void this.chatlog.append(id, {
+                    ts: Date.now(),
+                    role: "tool",
+                    text: `${e.tool}: ${e.inputSummary}`,
+                });
+                break;
+            case "permission":
+                this.hub.broadcast("event.permission_request", id, {
+                    ws: id,
+                    requestId: e.requestId,
+                    tool: e.tool,
+                    inputSummary: e.inputSummary,
+                });
+                void this.chatlog.append(id, {
+                    ts: Date.now(),
+                    role: "permission",
+                    text: e.inputSummary,
+                    requestId: e.requestId,
+                    tool: e.tool,
+                });
+                break;
+            case "permission_resolved":
+                // A new "allow all" rule retroactively cleared this request — tell every
+                // client to collapse its card, and stamp the transcript so a reconnect
+                // (or another device) reflects the same outcome.
+                this.hub.broadcast("event.permission_resolved", id, {
+                    ws: id,
+                    requestId: e.requestId,
+                    decision: e.decision,
+                });
+                void this.chatlog.resolvePermission(id, e.requestId, e.decision);
+                break;
+            case "ask_question":
+                this.hub.broadcast("event.ask_question", id, {
+                    ws: id,
+                    requestId: e.requestId,
+                    questions: e.questions,
+                });
+                void this.chatlog.append(id, {
+                    ts: Date.now(),
+                    role: "question",
+                    text: e.questions.map((q) => q.question).join(" · "),
+                    requestId: e.requestId,
+                    questions: e.questions,
+                });
+                break;
+            case "session":
+                live.record.sessionId = e.sessionId;
+                void this.persist();
+                this.hub.broadcast("event.session", id, {
+                    ws: id,
+                    sessionId: e.sessionId,
+                    status: live.record.status,
+                });
+                break;
+            case "status":
+                this.setStatus(live, e.status);
+                break;
+            case "done": {
+                const usageText = e.usage ? formatTurnUsage(e.usage) : undefined;
+                this.hub.broadcast("event.agent_done", id, { ws: id, summary: e.summary, usageText });
+                void this.chatlog.append(id, {
+                    ts: Date.now(),
+                    role: "system",
+                    text: `✓ done${e.summary ? ` — ${e.summary}` : ""}` +
+                        (usageText ? ` · ${usageText}` : ""),
+                });
+                // The turn almost certainly touched files, so the sidebar diff-stat is
+                // now stale — recompute and fan the fresh counts out (no-ops if the turn
+                // changed nothing). This keeps a background workspace's counter live
+                // even when no client is polling its git.status.
+                void this.broadcastWorkspaceList();
+                // Reactive-trigger seam: an agent turn just finished in this workspace.
+                this.events?.emitSystem({
+                    kind: "agent.done",
+                    ws: id,
+                    context: e.summary ? { summary: e.summary } : undefined,
+                });
+                break;
+            }
+            case "limit":
+                // Surface the limit so a client can offer to schedule a restart job at
+                // the reset time. Stamp the transcript so a reconnecting client still
+                // sees it happened (the actionable card rides the live event below).
+                this.hub.broadcast("event.session_limit", id, {
+                    ws: id,
+                    message: e.message,
+                    resetAt: e.resetAt,
+                });
+                // Persist as a `limit` entry (not a plain system line) so a reconnecting
+                // client replays the actionable restart card, not just static text.
+                void this.chatlog.append(id, {
+                    ts: Date.now(),
+                    role: "limit",
+                    text: e.message,
+                    resetAt: e.resetAt,
+                });
+                // Like `error`, a limit ends the turn without a `done`; finalize any
+                // dispatched job run so a scheduled restart that re-hits the limit
+                // doesn't leave a run (or ephemeral worktree) dangling.
+                this.events?.emitSystem({ kind: "agent.error", ws: id, context: { error: e.message } });
+                break;
+            case "error":
+                this.hub.broadcast("error", id, { code: "agent_error", message: e.message, ws: id });
+                // A failed turn emits no `done`; tell the scheduler so a dispatched job
+                // run finalizes (and its ephemeral worktree is not orphaned).
+                this.events?.emitSystem({
+                    kind: "agent.error",
+                    ws: id,
+                    context: e.message ? { error: e.message } : undefined,
+                });
+                break;
+        }
+    }
+    setStatus(live, status) {
+        live.record.status = status;
+        const id = live.record.id;
+        // status rides on event.session so the client updates the badge uniformly.
+        this.hub.broadcast("event.session", id, {
+            ws: id,
+            sessionId: live.record.sessionId ?? "",
+            status,
+        });
+    }
+    async shutdown() {
+        for (const live of this.workspaces.values()) {
+            await live.agent?.stop();
+            for (const dt of live.terminals.values())
+                dt.terminal?.dispose();
+        }
+        await this.persist();
+    }
+}
+/**
+ * A one-key env override for an agent subprocess, or `undefined` when no key is
+ * set — so the agent constructor leaves the environment untouched and its
+ * backend falls back to its own cached login (the SSO path).
+ */
+function envForKey(name, key) {
+    return key ? { [name]: key } : undefined;
+}
+/** Short human-readable reason from a thrown value, for batch-delete failures. */
+function errText(err) {
+    return (err instanceof Error ? err.message : String(err)).slice(0, 500);
+}
+//# sourceMappingURL=workspace.js.map