@dylanpiercey/work 0.0.203 → 0.0.205

package/dist/{_B9FeLAO5.js → _C_-lYJlp.js}

@@ -3,11 +3,44 @@ import { r as require_inherits, t as require_src$1 } from "./_xlrdOUsL.js";
 import { t as require_safe_buffer } from "./_BmSjjJ2E.js";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 import { execFile, execFileSync } from "node:child_process";
+import os from "node:os";
 import { promisify } from "node:util";
 import { DatabaseSync } from "node:sqlite";
 import { createHash } from "node:crypto";
+//#region src/server/http.ts
+/** Error whose `status` the API error-boundary middleware uses for the response. */
+function httpError(status, message) {
+	return Object.assign(new Error(message), { status });
+}
+/** The value of a Standard Schema `[value, issues]` pair, or a thrown 400
+* built from the issues. */
+function checked(result, what = "request") {
+	const [value, issues] = result;
+	if (issues) throw httpError(400, `invalid ${what}: ${issues.map((issue) => issue.message).join("; ")}`);
+	return value;
+}
+/** Validated request body, or a thrown 400 built from the valibot issues. */
+async function readBody(ctx) {
+	return checked(await ctx.body, "request body");
+}
+//#endregion
+//#region lib/setup/listen.mjs
+/** Addresses that mean every interface. */
+var EVERY = /* @__PURE__ */ new Set([
+	"0.0.0.0",
+	"::",
+	"*"
+]);
+/** The host to dial the server at, for WORK_LISTEN: loopback when it
+* listens on every interface or is unset, else the one address it listens
+* on (a server bound to `::1` or a LAN address refuses 127.0.0.1), bracketed
+* when IPv6 so it can go in a URL. */
+function dialHost(listen) {
+	if (!listen || EVERY.has(listen)) return "127.0.0.1";
+	return listen.includes(":") ? `[${listen}]` : listen;
+}
+//#endregion
 //#region src/server/config.ts
 var rawHome = os.homedir();
 var home$1 = rawHome && rawHome !== "undefined" && rawHome !== "null" ? rawHome : "";
@@ -42,6 +75,12 @@ var config = {
 	* from elsewhere is an auth wrapper's job (server/access.ts). Under
 	* systemd the socket unit binds, and `work setup` writes this into it. */
 	listen: process.env.WORK_LISTEN || "127.0.0.1",
+	/** The host this machine dials the server at, for what calls back into
+	* it (agent hooks, the push hook): loopback unless it listens on one
+	* address only. */
+	get dialHost() {
+		return dialHost(this.listen);
+	},
 	/** The auth wrapper's addresses when it runs on another machine (IPs or
 	* CIDRs, or `*`): the only peers besides this machine work answers. */
 	trustedProxies: list(process.env.WORK_TRUSTED_PROXIES),
@@ -72,7 +111,10 @@ async function run$1(cmd, args, cwd, env, opts = {}) {
 			killSignal: "SIGKILL"
 		}
 	});
-	if (opts.stdin !== void 0) child.child.stdin?.end(opts.stdin);
+	if (opts.stdin !== void 0) {
+		child.child.stdin?.on("error", () => {});
+		child.child.stdin?.end(opts.stdin);
+	}
 	const { stdout } = await child;
 	return stdout.trim();
 }
@@ -90,25 +132,46 @@ var GIT_NETWORK_MS = {
 	"ls-remote": 6e4
 };
 /** Never let git wait on a terminal it doesn't have — a missing credential
-* fails with a message instead of hanging the clone forever. */
+* fails with a message instead of hanging the clone forever. Optional
+* locks are off because most of what runs here is a background probe (the
+* review's stamp poll, Files, the language servers' change feed): a
+* `git status` refreshing the index holds `index.lock`, and an agent's
+* `git commit` or rebase step landing in that moment fails on it. */
 var git = async (args, cwd) => {
 	const verb = args.find((a) => !a.startsWith("-")) ?? "";
 	const timeoutMs = GIT_NETWORK_MS[verb];
 	try {
 		return await run$1("git", args, cwd, {
 			...process.env,
-			GIT_TERMINAL_PROMPT: "0"
+			GIT_TERMINAL_PROMPT: "0",
+			GIT_OPTIONAL_LOCKS: "0"
 		}, timeoutMs ? { timeoutMs } : void 0);
 	} catch (err) {
 		if (timeoutMs && err.killed) throw new Error(`git ${verb} timed out after ${Math.round(timeoutMs / 1e3)}s`);
 		throw err;
 	}
 };
+/** Ceilings for `gh`, for the reason git's network verbs have them: a
+* stalled call never settles, and the cached loaders behind it (the repo
+* catalog, repo metadata) hand that one promise to every later caller.
+* `repo list` pages through up to 500 repos; everything else is one API
+* call. */
+var GH_MS = { repo: 18e4 };
+var GH_DEFAULT_MS = 6e4;
 /** `gh` against one GitHub host — `GH_HOST` picks the stored credential. */
-var gh = (args, host) => run$1("gh", args, void 0, host ? {
-	...process.env,
-	GH_HOST: host
-} : void 0);
+var gh = async (args, host) => {
+	const verb = args[0] ?? "";
+	const timeoutMs = GH_MS[verb] ?? GH_DEFAULT_MS;
+	try {
+		return await run$1("gh", args, void 0, host ? {
+			...process.env,
+			GH_HOST: host
+		} : void 0, { timeoutMs });
+	} catch (err) {
+		if (err.killed) throw new Error(`gh ${verb} timed out after ${Math.round(timeoutMs / 1e3)}s`);
+		throw err;
+	}
+};
 var tmux = (args, env, opts) => run$1("tmux", [
 	"-L",
 	TMUX_SOCKET,
@@ -166,6 +229,7 @@ function get(sql, ...params) {
 function workspacePath(id) {
 	return get("SELECT path FROM workspaces WHERE id = ?", id)?.path;
 }
+var freshReview = !db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'review_comments'").get();
 db.exec(`
   PRAGMA journal_mode = WAL;
   PRAGMA foreign_keys = ON;
@@ -231,6 +295,7 @@ db.exec(`
     PRIMARY KEY (workspace_id, key)
   );
 `);
+if (freshReview) db.prepare("INSERT OR IGNORE INTO settings (key, value) VALUES ('review-cleared-diff-v2', '1')").run();
 /** Additive schema changes: `CREATE TABLE IF NOT EXISTS` never revisits a
 * table that already exists, so a column added after a release has to be
 * bolted on here for databases created before it. */
@@ -243,6 +308,83 @@ ensureColumn("workspaces", "materialized", "INTEGER NOT NULL DEFAULT 1");
 ensureColumn("workspaces", "origin_branch", "TEXT");
 ensureColumn("workspaces", "imported_at", "TEXT");
 //#endregion
+//#region src/client/pref-change.ts
+/** The stored text after `change`, or null when nothing is left. A value
+* of another shape (unreadable, or another build's) counts as empty, as
+* client/prefs' readers treat it. */
+function applyPrefChange(raw, change) {
+	let value;
+	try {
+		value = raw == null ? void 0 : JSON.parse(raw);
+	} catch {}
+	const kept = compact(change.op === "set" ? within(value, change.at, () => change.value ?? void 0) : within(value, change.at ?? [], (list) => listChange(asList(list), change)));
+	return kept === void 0 ? null : JSON.stringify(kept);
+}
+function listChange(list, change) {
+	const { item } = change;
+	const other = (x) => !same(x, item);
+	if (change.op === "remove") return list.filter(other);
+	if (change.op === "push") return [item, ...list.filter(other)].slice(0, change.cap);
+	const at = change.over === void 0 ? -1 : list.findIndex((x) => same(x, change.over));
+	if (at >= 0) return list.map((x, i) => i === at ? item : x).filter((x, i) => i === at || other(x));
+	if (!list.every(other)) return list;
+	return change.cap != null && list.length >= change.cap ? list : [...list, item];
+}
+/** `node` with `fn` applied at `path`, copied along the way. Undefined
+* from `fn` drops an object field, or clears a list slot. Objects have no
+* prototype, so a field named `__proto__` is only a field. */
+function within(node, path, fn) {
+	if (!path.length) return fn(node);
+	const [step, ...rest] = path;
+	if (typeof step === "number") {
+		const list = asList(node).slice();
+		while (list.length < step) list.push(null);
+		list[step] = within(list[step], rest, fn) ?? null;
+		return list;
+	}
+	const obj = asObj(node);
+	const v = within(obj[step], rest, fn);
+	if (v === void 0) delete obj[step];
+	else obj[step] = v;
+	return obj;
+}
+function asList(node) {
+	return Array.isArray(node) ? node : [];
+}
+function asObj(node) {
+	const obj = Object.create(null);
+	if (node && typeof node === "object" && !Array.isArray(node)) Object.assign(obj, node);
+	return obj;
+}
+/** Null, `[]` and `{}` read as nothing, so none is stored: a list's
+* trailing empty slots go, and a value left empty removes the row. */
+function compact(v) {
+	if (Array.isArray(v)) {
+		const list = v.map((x) => compact(x) ?? null);
+		while (list.length && list[list.length - 1] === null) list.pop();
+		return list.length ? list : void 0;
+	}
+	if (v && typeof v === "object") {
+		const obj = Object.create(null);
+		for (const [k, x] of Object.entries(v)) {
+			const c = compact(x);
+			if (c !== void 0) obj[k] = c;
+		}
+		return Object.keys(obj).length ? obj : void 0;
+	}
+	return v ?? void 0;
+}
+/** Equal as JSON: a field holding undefined is no field (a page's own
+* copy has those; what the server parsed never does). */
+function same(a, b) {
+	if (a === b) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const keys = (o) => Object.keys(o).filter((k) => o[k] !== void 0);
+	const ka = keys(a);
+	return ka.length === keys(b).length && ka.every((k) => same(a[k], b[k]));
+}
+//#endregion
 //#region lib/setup/agents.json
 var agents_default = [
 	{
@@ -700,6 +842,22 @@ async function githubHostStatus(host) {
 		error: /not logged in/i.test(text) ? void 0 : text.trim().split("\n").pop()
 	};
 }
+/** Whether the server can keep this Linux host awake (src/server/awake.ts
+* holds the lock itself). Its last resort, an `idle` lock, is one polkit
+* grants anyone, so failing that means nothing holds the host while work
+* runs, and a suspend looks like the network dropping. Null off Linux, where
+* caffeinate asks no one. */
+async function canStayAwake() {
+	if (process.platform !== "linux") return null;
+	const { ok } = await run("systemd-inhibit", [
+		"--what=idle",
+		"--mode=block",
+		"--who=work",
+		"--why=work doctor probe",
+		"true"
+	], { timeout: 5e3 });
+	return ok;
+}
 /**
 * Full readiness snapshot.
 *
@@ -712,7 +870,11 @@ async function doctor(opts = {}) {
 		...opts.hosts || [],
 		...ghKnownHosts()
 	]);
-	const [versions, github] = await Promise.all([miseVersions(), Promise.all([...hostSet].map(githubHostStatus))]);
+	const [versions, github, awake] = await Promise.all([
+		miseVersions(),
+		Promise.all([...hostSet].map(githubHostStatus)),
+		canStayAwake()
+	]);
 	const tools = TOOLS.map((t) => {
 		const found = which(t.bin);
 		return {
@@ -740,7 +902,8 @@ async function doctor(opts = {}) {
 		},
 		tools,
 		agents,
-		github
+		github,
+		awake
 	};
 }
 //#endregion
@@ -758,10 +921,44 @@ function allPrefs() {
 	const rows = db.prepare("SELECT key, value FROM settings WHERE key LIKE 'ui.%'").all();
 	return Object.fromEntries(rows.map((r) => [r.key.slice(3), r.value]));
 }
+/** The most a pref may hold: every one rides each page's HTML. */
+var PREF_MAX = 4096;
+/** The prefs kept per workspace, keyed `<name>:<workspace id>`. They ride
+* every page's HTML, so they go with the workspace (`deleteWorkspacePrefs`)
+* and /api/prefs refuses them for one that is gone; one missing here
+* outlives its workspace for good. `scripts/migrate.mjs` prunes orphans of
+* the same list. */
+var WORKSPACE_PREFS = [
+	"tab",
+	"diff-filter",
+	"diff-folded",
+	"diff-focus",
+	"diff-pos",
+	"files-recent"
+];
+function deleteWorkspacePrefs(id) {
+	const keys = WORKSPACE_PREFS.map((name) => `ui.${name}:${id}`);
+	db.prepare(`DELETE FROM settings WHERE key IN (${keys.map(() => "?").join(", ")})`).run(...keys);
+}
 function setPref(key, value) {
 	if (value === null) db.prepare("DELETE FROM settings WHERE key = ?").run(`ui.${key}`);
 	else setSetting(`ui.${key}`, value);
 }
+/** Apply one change to a list or object pref as it is stored now — not
+* as the page that sent it last read it — and return the result. */
+function changePref(key, change) {
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		const next = applyPrefChange(getSetting(`ui.${key}`) ?? null, change);
+		if (next !== null && next.length > 4096) throw httpError(413, `pref ${key} would be over ${PREF_MAX} characters`);
+		setPref(key, next);
+		db.exec("COMMIT");
+		return next;
+	} catch (err) {
+		db.exec("ROLLBACK");
+		throw err;
+	}
+}
 /** Instance ids the user switched off in Settings (still installed). */
 function disabledAgents() {
 	try {
@@ -6867,6 +7064,7 @@ function agentFromCommand(command) {
 }
 //#endregion
 //#region src/server/agent-state.ts
+/** What the turn is doing, as its hooks said. */
 var phases = /* @__PURE__ */ new Map();
 var scraped = /* @__PURE__ */ new Map();
 var reasons = /* @__PURE__ */ new Map();
@@ -6878,6 +7076,12 @@ var pendingDone = /* @__PURE__ */ new Map();
 * a session whose hooks never report (not loaded, not trusted, turned
 * off) is left to the pane scraper rather than to silence. */
 var reportedAt = /* @__PURE__ */ new Map();
+/** Work each session runs apart from its turn and wakes up for as it
+* ends (Claude's background subagents and workflows), by id; only
+* sessions with some. A turn that ends while any runs has handed off, not
+* finished: the session is working until a turn ends with none left, and
+* that end is the one pushed. */
+var background = /* @__PURE__ */ new Map();
 /** A turn's end is pushed once it has stayed ended this long. Stop fires
 * again each time something sends the agent back to work (a stop hook
 * that continues it, a goal loop, background subagents reporting in), and
@@ -6899,7 +7103,7 @@ function setAgentPhase(sessionId, phase, reason, summary) {
 		const failed = phases.get(sessionId) === "waiting" && reasons.get(sessionId) === "attention";
 		if (summary) summaries.set(sessionId, summary);
 		if (phases.has(sessionId)) applyChange(sessionId, () => dropHook(sessionId));
-		if (!failed) pendingDone.set(sessionId, setTimeout(() => {
+		if (!failed && !background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
 			pendingDone.delete(sessionId);
 			notify(sessionId, "done");
 		}, DONE_SETTLE_MS));
@@ -6921,15 +7125,31 @@ function dropHook(sessionId) {
 	phases.delete(sessionId);
 	reasons.delete(sessionId);
 }
+/** A hook's word on the session's background work: the CLI's own list of
+* what runs, or one piece starting or ending. It says nothing of the turn,
+* whose phase is left as it was (a subagent starting beside a question on
+* screen leaves the question). */
+function noteBackground(sessionId, work) {
+	reportedAt.set(sessionId, Date.now());
+	const ids = new Set(work.running ?? background.get(sessionId));
+	if (work.started) ids.add(work.started);
+	if (work.stopped) ids.delete(work.stopped);
+	if (ids.size) cancelDone(sessionId);
+	applyChange(sessionId, () => {
+		if (ids.size) background.set(sessionId, ids);
+		else background.delete(sessionId);
+	});
+}
 function cancelDone(sessionId) {
 	const timer = pendingDone.get(sessionId);
 	if (!timer) return;
 	clearTimeout(timer);
 	pendingDone.delete(sessionId);
 }
-/** What the session's hooks last said, apart from the scraper. */
+/** What the session's hooks last said, apart from the scraper: the
+* turn's phase, else working while its background work runs. */
 function hookPhase(sessionId) {
-	return phases.get(sessionId);
+	return phases.get(sessionId) ?? (background.has(sessionId) ? "working" : void 0);
 }
 /** When the session's hooks last reported (undefined: never, this run). */
 function hookReportedAt(sessionId) {
@@ -6937,10 +7157,16 @@ function hookReportedAt(sessionId) {
 }
 /** A hook's "working" whose pane has gone still: the turn ended without
 * a hook saying so (an interrupt, a failure the CLI reports no hook for),
-* since every agent's screen animates while it works. Idle, no push. */
+* or its background work did (an end whose hook was lost, a turn it should
+* have woken that never came), since every agent's screen animates while
+* it works — Claude's ticks a line for background work every second.
+* Idle, no push. */
 function settleQuietWorking(sessionId) {
-	if (phases.get(sessionId) !== "working") return;
-	applyChange(sessionId, () => dropHook(sessionId));
+	if (hookPhase(sessionId) !== "working") return;
+	applyChange(sessionId, () => {
+		dropHook(sessionId);
+		background.delete(sessionId);
+	});
 }
 /** The user answered at the terminal while the session was stopped on
 * them (approved, denied, picked, interrupted): no longer waiting on
@@ -7003,17 +7229,18 @@ function clearAgentPhase(sessionId) {
 	cancelDone(sessionId);
 	summaries.delete(sessionId);
 	reportedAt.delete(sessionId);
-	if (!phases.has(sessionId) && !scraped.has(sessionId)) return;
+	if (!phases.has(sessionId) && !scraped.has(sessionId) && !background.has(sessionId)) return;
 	applyChange(sessionId, () => {
 		phases.delete(sessionId);
 		scraped.delete(sessionId);
 		reasons.delete(sessionId);
+		background.delete(sessionId);
 	});
 }
 /** What a session is doing. The hook wins where there is one: it reports
 * the turn itself, where tmux only sees the pane still moving after it. */
 function agentPhase(sessionId) {
-	return phases.get(sessionId) ?? scraped.get(sessionId);
+	return hookPhase(sessionId) ?? scraped.get(sessionId);
 }
 /** Apply a mutation and broadcast when it moved the session's phase (or,
 * `force`, its reason: finished and blocked draw differently). Only a
@@ -7031,7 +7258,7 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_7W8iLTql.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_CWyeRc54.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -7046,7 +7273,7 @@ function publishChange(sessionId) {
 * does not report as that session's agent. */
 function stateCurl(family, state, reason) {
 	const qs = `session=$WORK_SESSION_ID&agent=${family}&state=${state}` + (reason ? `&reason=${reason}` : "");
-	return `[ -n "$WORK_SESSION_ID" ] && curl -sf --connect-timeout 1 -m 2 -X POST "http://127.0.0.1:\${WORK_APP_PORT:-${config.appPort}}/api/agent-state?${qs}" -H 'content-type: application/json' --data-binary @- >/dev/null 2>&1; exit 0`;
+	return `[ -n "$WORK_SESSION_ID" ] && curl -sf --connect-timeout 1 -m 2 -X POST "http://${config.dialHost}:\${WORK_APP_PORT:-${config.appPort}}/api/agent-state?${qs}" -H 'content-type: application/json' --data-binary @- >/dev/null 2>&1; exit 0`;
 }
 /** Claude-format hook groups (`{matcher?, hooks:[{type:"command",command}]}`)
 * for a hook map — the JSON shape Claude, Copilot plugins and Grok all read. */
@@ -7351,29 +7578,40 @@ function numberedDirs() {
 	}
 }
 /** OAuth credentials: `.credentials.json` in the config dir on Linux; on
-* macOS Claude Code keeps them in the login keychain instead (service
-* "Claude Code-credentials"), which `security` reads back as the same JSON.
-* The keychain read is cached per process tick of the usage refresh — it
-* forks a process — and only tried for the primary account. Read once per
-* account per refresh: a row asks for them half a dozen times, and every
-* refresh lists the accounts afresh. */
+* macOS Claude Code keeps them in the login keychain instead, which
+* `security` reads back as the same JSON. The keychain read is cached for
+* 30 s per account — it forks a process. Read once per account per
+* refresh: a row asks for them half a dozen times, and every refresh lists
+* the accounts afresh. */
 var credentialsRead = /* @__PURE__ */ new WeakMap();
 var credentials = (account) => {
 	if (credentialsRead.has(account)) return credentialsRead.get(account);
 	let cred = readJson(path.join(account.dir, ".credentials.json"));
-	if (!cred && process.platform === "darwin" && !account.suffix) cred = keychainCredentials();
+	if (!cred && process.platform === "darwin") cred = keychainCredentials(keychainService(account));
 	credentialsRead.set(account, cred);
 	return cred;
 };
-var keychain = null;
-function keychainCredentials() {
-	if (keychain && Date.now() - keychain.at < 3e4) return keychain.value;
+/** The keychain item Claude Code keeps an account under: "Claude
+* Code-credentials" for the stock install, and for one run with
+* `CLAUDE_CONFIG_DIR` that name plus the first 8 hex digits of the
+* SHA-256 of the dir as the variable gives it (NFC). A numbered account's
+* dir is `$HOME/.claude-<n>`, which is what `CLAUDE_CONFIG_DIR` holds. */
+function keychainService(account) {
+	const base = "Claude Code-credentials";
+	if (!account.suffix) return base;
+	const dir = account.dir.normalize("NFC");
+	return `${base}-${createHash("sha256").update(dir).digest("hex").slice(0, 8)}`;
+}
+var keychain = /* @__PURE__ */ new Map();
+function keychainCredentials(service) {
+	const cached = keychain.get(service);
+	if (cached && Date.now() - cached.at < 3e4) return cached.value;
 	let value = null;
 	try {
 		const raw = execFileSync("security", [
 			"find-generic-password",
 			"-s",
-			"Claude Code-credentials",
+			service,
 			"-w"
 		], {
 			encoding: "utf8",
@@ -7387,10 +7625,10 @@ function keychainCredentials() {
 		const parsed = JSON.parse(raw.trim());
 		value = parsed && typeof parsed === "object" ? parsed : null;
 	} catch {}
-	keychain = {
+	keychain.set(service, {
 		at: Date.now(),
 		value
-	};
+	});
 	return value;
 }
 /** Why an account has no live data — an expired token is the common case
@@ -7567,14 +7805,33 @@ var FAILURES = {
 	max_output_tokens: "Hit the output limit",
 	cloud_credential_error: "Cloud credentials failed"
 };
-/** Claude's dialect: subagents' tool calls left out, the question tool's
-* prompt, the command awaiting approval and a failed turn's error as the
-* summary, and a Stop that hands off to background subagents not counted
-* as the turn's end. */
+/** Claude's dialect: subagents' tool calls left out, their starts and
+* stops and a Stop's list of what still runs read as background work (a
+* Stop with some running has handed off, not finished: agent-state), the
+* question tool's prompt, the command awaiting approval and a failed
+* turn's error as the summary. */
 function readHook$6(p, reported, _state) {
 	const event = p.hook_event_name;
+	if (event === "SubagentStart") {
+		const id = str$1(p.agent_id);
+		return id ? {
+			ignore: true,
+			background: { started: id }
+		} : { ignore: true };
+	}
+	if (event === "SubagentStop") {
+		const running = backgroundWork(p);
+		const id = str$1(p.agent_id);
+		if (running) return {
+			ignore: true,
+			background: { running }
+		};
+		return id ? {
+			ignore: true,
+			background: { stopped: id }
+		} : { ignore: true };
+	}
 	if ((event === "PreToolUse" || event === "PostToolUse" || event === "PostToolUseFailure") && str$1(p.agent_id)) return { ignore: true };
-	if (event === "Stop" && runningSubagents(p)) return { ignore: true };
 	if (event === "PostToolUseFailure" && p.is_interrupt === true) return { state: "idle" };
 	if (notificationType(p) === WORKER_PERMISSION) return {
 		reason: "attention",
@@ -7598,15 +7855,28 @@ function readHook$6(p, reported, _state) {
 		const input = p.tool_input;
 		const what = str$1(input?.description) || str$1(input?.command) || str$1(p.tool_name);
 		read.summary = what ? cleanSummary(`Approve: ${what}`) : "Waiting for permission";
+	} else if (event === "Stop") {
+		const running = backgroundWork(p);
+		if (running) read.background = { running };
 	}
 	return read;
 }
-/** Stop's `background_tasks` (in-flight work that will wake the session)
-* holding a subagent. A background shell (a dev server) is left out: it
-* may never finish, and the turn really has ended. */
-function runningSubagents(p) {
+/** The kinds of `background_tasks` entry Claude wakes up for as they end
+* and waits on itself: subagents and workflows. A background shell (a dev
+* server) may never end, a monitor fires for as long as it runs and a
+* teammate idles between tasks, so none of those is work in progress. */
+var WAKES = /* @__PURE__ */ new Set(["subagent", "workflow"]);
+/** The ids of the work that wakes the session among a Stop's or
+* SubagentStop's `background_tasks` (running or pending), or undefined
+* for a payload without the list. */
+function backgroundWork(p) {
 	const tasks = p.background_tasks;
-	return Array.isArray(tasks) && tasks.some((t) => !!t && typeof t === "object" && t.type === "subagent");
+	if (!Array.isArray(tasks)) return void 0;
+	return tasks.flatMap((t) => {
+		const task = t ?? {};
+		const id = str$1(task.id);
+		return id && WAKES.has(str$1(task.type)) ? [id] : [];
+	});
 }
 /** Claude Code takes its settings inline (`--settings` accepts a JSON
 * string), so the hooks travel in argv and nothing is written anywhere.
@@ -7615,7 +7885,12 @@ function runningSubagents(p) {
 * while (each keystroke defers it), but it is the one that covers a
 * sandbox's network prompt. A turn that fails (rate limit, signed out)
 * ends with StopFailure rather than Stop; an interrupt ends with no hook
-* at all, which the pane going still catches (scraper.ts). */
+* at all, which the pane going still catches (scraper.ts). Subagents
+* report starting and stopping (SubagentStart / SubagentStop, with their
+* `agent_id`), a background one and a workflow's among them, and Stop and
+* SubagentStop carry `background_tasks`, Claude's own list of what still
+* runs: together, what keeps a session working past a turn that handed
+* its work to them. */
 var claude = {
 	meta: meta$6,
 	launchFlags: () => ["--settings", JSON.stringify({ hooks: claudeStyleHooks("claude", [
@@ -7649,6 +7924,8 @@ var claude = {
 			"waiting",
 			"attention"
 		],
+		["SubagentStart", "background"],
+		["SubagentStop", "background"],
 		[
 			"Notification",
 			"waiting",
@@ -7658,7 +7935,10 @@ var claude = {
 	]) })],
 	reportsWorking: () => true,
 	envPrefixes: ["CLAUDE", "AI_AGENT"],
-	startupPrompt: (screen) => /Is this a project you created or one you trust/.test(screen) ? ["Enter"] : void 0,
+	startupQuestions: [{
+		screen: /Is this a project you created or one you trust/,
+		asks: "whether to trust this folder"
+	}],
 	readHook: readHook$6,
 	usage: () => Promise.all(claudeAccounts().map((account) => claudeRow(account)))
 };
@@ -8105,19 +8385,16 @@ function lastMessageFromTranscript(p) {
 		}
 	} catch {}
 }
-/** Two menus Copilot can draw before its input box, both of which would
-* swallow a pasted first prompt. A session work ends is killed with its
-* tmux pane, so Copilot's own registry still lists it as open and every
-* later launch offers to restore it (Esc starts fresh). A workspace it has
-* not seen gets the folder-trust prompt, with Yes preselected. */
-function startupPrompt(screen) {
-	if (/Restore interrupted sessions/.test(screen)) return ["Escape"];
-	if (/remember this folder for future sessions/.test(screen)) return ["Enter"];
-}
 var copilot = {
 	meta: meta$4,
 	launchFlags: () => ["--plugin-dir", pluginDir$1()],
-	startupPrompt,
+	startupQuestions: [{
+		screen: /remember this folder for future sessions/,
+		asks: "whether to trust this folder"
+	}, {
+		screen: /Restore interrupted sessions/,
+		asks: "which sessions to restore"
+	}],
 	reportsWorking: () => true,
 	envPrefixes: ["COPILOT_"],
 	readHook: readHook$4,
@@ -8593,7 +8870,7 @@ var meta$1 = meta_default$1;
 * subscribed to the same event bus its TUI renders from. The plugin posts
 * the reports itself rather than shelling out to curl, so this is the one
 * family whose payload work wrote — `readHook` only has to unwrap it. */
-var PLUGIN = (appPort) => `// Generated by work. Reports this
+var PLUGIN = (host, appPort) => `// Generated by work. Reports this
 // session's working / needs-input / done state to the app; edits are
 // overwritten. Port and session id come from the env tmux gave the pane.
 const post = async (state, reason, summary) => {
@@ -8604,7 +8881,7 @@ const post = async (state, reason, summary) => {
     \`session=\${encodeURIComponent(session)}&agent=opencode&state=\${state}\` +
     (reason ? \`&reason=\${reason}\` : "");
   try {
-    await fetch(\`http://127.0.0.1:\${port}/api/agent-state?\${qs}\`, {
+    await fetch(\`http://${host}:\${port}/api/agent-state?\${qs}\`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({ summary }),
@@ -8739,7 +9016,7 @@ function installed$1() {
 function pluginConfig() {
 	const file = PLUGIN_FILE();
 	try {
-		writeIfChanged(file, PLUGIN(config.appPort));
+		writeIfChanged(file, PLUGIN(config.dialHost, config.appPort));
 	} catch {}
 	return JSON.stringify({ plugin: [file] });
 }
@@ -8770,7 +9047,7 @@ var meta = meta_default;
 * `agent_settled` (0.80.4) never sends it, so a run's end waits a moment
 * for one and reports itself when none comes. The extension posts its own
 * reports, as opencode's plugin does; `readHook` only unwraps them. */
-var EXTENSION = (appPort) => `// Generated by work. Reports this
+var EXTENSION = (host, appPort) => `// Generated by work. Reports this
 // session's working / needs-input / done state to the app; edits are
 // overwritten. Port and session id come from the env tmux gave the pane.
 const post = async (state, reason, summary) => {
@@ -8781,7 +9058,7 @@ const post = async (state, reason, summary) => {
     \`session=\${encodeURIComponent(session)}&agent=pi&state=\${state}\` +
     (reason ? \`&reason=\${reason}\` : "");
   try {
-    await fetch(\`http://127.0.0.1:\${port}/api/agent-state?\${qs}\`, {
+    await fetch(\`http://${host}:\${port}/api/agent-state?\${qs}\`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({ summary }),
@@ -8847,7 +9124,7 @@ function installed() {
 function extensionFile() {
 	const file = EXTENSION_FILE();
 	try {
-		writeIfChanged(file, EXTENSION(config.appPort));
+		writeIfChanged(file, EXTENSION(config.dialHost, config.appPort));
 	} catch {}
 	return file;
 }
@@ -8898,17 +9175,12 @@ function agentLaunchEnv(id, ctx) {
 function reportsWorking(id) {
 	return agentFor(id)?.reportsWorking?.() ?? false;
 }
-/** The pane title a CLI shows at its prompt, if it sets one. */
-function idleTitle(id) {
-	return agentFor(id)?.idleTitle;
-}
-/** The CLI draws menus before its input box that work answers. */
-function hasStartupPrompt(id) {
-	return !!agentFor(id)?.startupPrompt;
-}
-/** Keys that answer whatever startup prompt the CLI is showing, if any. */
-function startupPromptKeys(id, screen) {
-	return agentFor(id)?.startupPrompt?.(screen);
+/** What the CLI is asking the user on this screen before its input box
+* ("Claude is asking whether to trust this folder"), if anything. */
+function startupQuestion(id, screen) {
+	const agent = agentFor(id);
+	const question = agent?.startupQuestions?.find((q) => q.screen.test(screen));
+	return agent && question ? `${agent.meta.label} is asking ${question.asks}` : void 0;
 }
 /** The input-box marker for CLIs whose splash looks settled early. */
 function readyScreen(id) {
@@ -8943,8 +9215,16 @@ function listSessions(workspaceId) {
 function getSession(id) {
 	return get("SELECT * FROM sessions WHERE id = ?", id);
 }
-function createSession(workspaceId, agent) {
+/** `ifEmpty` is a first open's auto-create: two pages mounting one empty
+* workspace at once (restored tabs, a phone and a desktop) both list no
+* sessions before either POST lands. The check and the insert run in one
+* synchronous step, so the second gets the first one's session. */
+function createSession(workspaceId, agent, ifEmpty = false) {
 	if (!isKnownAgent(agent)) throw new Error(`unknown session kind: ${agent}`);
+	if (ifEmpty) {
+		const first = listSessions(workspaceId)[0];
+		if (first) return first;
+	}
 	const id = Math.random().toString(36).slice(2, 10);
 	db.prepare("INSERT INTO sessions (id, workspace_id, agent) VALUES (?, ?, ?)").run(id, workspaceId, agent);
 	notifySessionsChanged(workspaceId);
@@ -9030,14 +9310,29 @@ async function sendToSession(id, text, size) {
 	if (!wsPath) throw new Error("unknown workspace");
 	const name = tmuxName(id);
 	const env = cleanEnv();
-	if (!await tmux([
+	const alive = await tmux([
 		"has-session",
 		"-t",
 		name
-	], env).then(() => true, () => false)) {
+	], env).then(() => true, () => false);
+	if (!alive) {
 		await ensureTmuxServer();
+		clearAgentPhase(id);
 		if (promptAsArgv(session.agent)) {
-			await tmux(newSessionArgs(session, wsPath, "-d", text, size), env);
+			const file = path.join(os.tmpdir(), `work-prompt-${id}-${Math.random().toString(36).slice(2, 10)}`);
+			fs.writeFileSync(file, text, {
+				mode: 384,
+				flag: "wx"
+			});
+			try {
+				await tmux(newSessionArgs(session, wsPath, "-d", {
+					file,
+					text
+				}, size), env);
+			} catch (err) {
+				fs.rmSync(file, { force: true });
+				throw err;
+			}
 			markTmuxStarted(id);
 			return;
 		}
@@ -9045,6 +9340,16 @@ async function sendToSession(id, text, size) {
 		markTmuxStarted(id);
 		await waitForAgent(name, env, session.agent);
 	}
+	if (!alive || hookReportedAt(id) === void 0) {
+		const screen = await tmux([
+			"capture-pane",
+			"-p",
+			"-t",
+			name
+		], env).catch(() => "");
+		const asking = startupQuestion(session.agent, screen);
+		if (asking) throw httpError(409, `${asking}: answer it in the terminal, then send again`);
+	}
 	const buffer = `work-send-${Math.random().toString(36).slice(2, 8)}`;
 	await tmux([
 		"load-buffer",
@@ -9117,19 +9422,18 @@ async function listPanesNow() {
 		"list-panes",
 		"-a",
 		"-F",
-		"#{session_name}	#{pane_current_command}	#{pane_pid}	#{window_activity}	#{pane_title}"
+		"#{session_name}	#{pane_current_command}	#{pane_pid}	#{window_activity}"
 	]).catch(() => null);
 	if (out === null) return null;
 	const panes = [];
 	for (const line of out.split("\n")) {
 		if (!line) continue;
-		const [name, command, pid, stamp, ...title] = line.split("	");
+		const [name, command, pid, stamp] = line.split("	");
 		panes.push({
 			id: name?.startsWith("wk-") ? name.slice(3) : void 0,
 			command: command || "",
 			pid: Number(pid),
-			activityAt: Number(stamp) * 1e3,
-			title: title.join("	")
+			activityAt: Number(stamp) * 1e3
 		});
 	}
 	lastPanes = {
@@ -9162,7 +9466,7 @@ async function ensureTmuxServer() {
 	portCleared = true;
 	await run$1("systemd-run", [
 		"--user",
-		"--unit=work-tmux",
+		`--unit=${TMUX_SOCKET === "work" ? "work-tmux" : `work-tmux-${TMUX_SOCKET.replace(/[^\w.:-]/g, "_")}`}`,
 		"--service-type=forking",
 		"--collect",
 		"tmux",
@@ -9296,15 +9600,16 @@ function newSessionArgs(session, wsPath, mode, initialPrompt, size) {
 function loginShellCommand(agent, cwd, initialPrompt) {
 	const words = sessionCommand(agent);
 	if (!words.length) return [];
-	const line = [
-		...words,
-		...agentLaunchFlags(agent, { cwd }),
-		...initialPrompt ? initialPrompt.startsWith("-") ? ["--", initialPrompt] : [initialPrompt] : []
-	].map(shellQuote).join(" ");
+	const line = [...words, ...agentLaunchFlags(agent, { cwd })].map(shellQuote);
+	if (initialPrompt) {
+		const file = shellQuote(initialPrompt.file);
+		if (initialPrompt.text.startsWith("-")) line.push("--");
+		line.push(`"$(cat ${file}; rm -f ${file})"`);
+	}
 	return [
 		process.env.SHELL || "bash",
 		"-lc",
-		`exec ${line}`
+		`exec ${line.join(" ")}`
 	];
 }
 function shellQuote(word) {
@@ -9328,14 +9633,6 @@ function cleanEnv() {
 	env.PATH = [...parts, ...bins.filter((bin) => !parts.includes(bin))].join(":");
 	return forceUtf8Locale(env);
 }
-/** Answer the menus a CLI draws before its input box (a folder-trust
-* question) on a pane an attach just created, as sending a first prompt
-* does — so a session opened with nothing to send is not left on one. */
-async function settleStartup(id) {
-	const session = getSession(id);
-	if (!session || !hasStartupPrompt(session.agent)) return;
-	await waitForAgent(tmuxName(id), cleanEnv(), session.agent).catch(() => {});
-}
 /** Upper bound on waiting for an agent to be ready for input; past it
 * the paste goes in regardless (a TUI with a boot animation never settles). */
 var AGENT_BOOT_MS = 8e3;
@@ -9357,24 +9654,7 @@ async function waitForAgent(name, env, agent) {
 		if (c && !/^(bash|zsh|sh|fish|login|-?\w*sh)$/.test(c)) break;
 		await sleep(150);
 	}
-	const ready = readyScreen(agent);
-	for (let i = 0; i < 3; i++) {
-		await waitStill(name, env, until - Date.now(), ready);
-		const keys = startupPromptKeys(agent, await tmux([
-			"capture-pane",
-			"-p",
-			"-t",
-			name
-		], env).catch(() => ""));
-		if (!keys?.length) return;
-		await tmux([
-			"send-keys",
-			"-t",
-			name,
-			...keys
-		], env);
-		await sleep(300);
-	}
+	await waitStill(name, env, until - Date.now(), readyScreen(agent));
 }
 /** Resolve once the pane has drawn something and then held still for
 * SCREEN_STILL_MS, or after `maxMs` (a TUI with an animation never
@@ -9441,4 +9721,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { validSubscription as $, hookPhase as A, get as At, agentFromCommand as B, AGENTS as C, DEFAULT_GITHUB_HOST as Ct, blankRow as D, toolById as Dt, reportsWorking as E, agentLabel$1 as Et, setScrapedPhase as F, run$1 as Ft, iconSvg as G, agentMeta as H, setSessionViewers as I, tmux as It, setInstance as J, manifest as K, settleQuietWorking as L, config as Lt, noteUserAnswered as M, TMUX_SOCKET as Mt, onPhaseChange as N, gh as Nt, agentPhase as O, all as Ot, setAgentPhase as P, git as Pt, sendPush as Q, agentBadge as R, tmuxWasStarted as S, which as St, readHookPayload as T, agentById as Tt, ACCENT_RE as U, agentLabel as V, getInstance as W, pushPublicKey as X, deleteSubscription as Y, saveSubscription as Z, renameSession as _, doctor as _t, ensureTmuxServer as a, swr as at, settleStartup as b, miseVersions as bt, killSession as c, allPrefs as ct, listPanesWithin as d, getSetting as dt, publish as et, listSessions as f, preferredAgent as ft, panePids as g, discoverAgents as gt, notifySessionsChanged as h, setSetting as ht, disposeSessions as i, shared as it, hookReportedAt as j, workspacePath as jt, clearAgentPhase as k, db as kt, killWorkspaceSessions as l, disabledAgents as lt, newSessionArgs as m, setPref as mt, clearTmuxStarted as n, subscribe as nt, forgetPanes as o, withLock as ot, markTmuxStarted as p, setDisabledAgents as pt, normalizeAccent as q, createSession as r, subscriberCount as rt, getSession as s, agentChoices as st, cleanEnv as t, publishJson as tt, listPanes as u, enabledAgents as ut, sendToSession as v, ghKnownHosts as vt, idleTitle as w, TOOLS as wt, tmuxName as x, setupPath as xt, sessionStates as y, miseInstalls as yt, agentFamily as z };
+export { publish as $, noteBackground as A, toolById as At, agentLabel as B, tmux as Bt, readHookPayload as C, miseVersions as Ct, clearAgentPhase as D, TOOLS as Dt, agentPhase as E, DEFAULT_GITHUB_HOST as Et, setSessionViewers as F, workspacePath as Ft, manifest as G, ACCENT_RE as H, checked as Ht, settleQuietWorking as I, TMUX_SOCKET as It, deleteSubscription as J, normalizeAccent as K, agentBadge as L, gh as Lt, onPhaseChange as M, all as Mt, setAgentPhase as N, db as Nt, hookPhase as O, agentById as Ot, setScrapedPhase as P, get as Pt, validSubscription as Q, agentFamily as R, git as Rt, AGENTS as S, miseInstalls as St, blankRow as T, which as Tt, getInstance as U, httpError as Ut, agentMeta as V, config as Vt, iconSvg as W, readBody as Wt, saveSubscription as X, pushPublicKey as Y, sendPush as Z, renameSession as _, setPref as _t, ensureTmuxServer as a, withLock as at, tmuxName as b, doctor as bt, killSession as c, agentChoices as ct, listPanesWithin as d, deleteWorkspacePrefs as dt, publishJson as et, listSessions as f, disabledAgents as ft, panePids as g, setDisabledAgents as gt, notifySessionsChanged as h, preferredAgent as ht, disposeSessions as i, swr as it, noteUserAnswered as j, applyPrefChange as jt, hookReportedAt as k, agentLabel$1 as kt, killWorkspaceSessions as l, allPrefs as lt, newSessionArgs as m, getSetting as mt, clearTmuxStarted as n, subscriberCount as nt, forgetPanes as o, PREF_MAX as ot, markTmuxStarted as p, enabledAgents as pt, setInstance as q, createSession as r, shared as rt, getSession as s, WORKSPACE_PREFS as st, cleanEnv as t, subscribe as tt, listPanes as u, changePref as ut, sendToSession as v, setSetting as vt, reportsWorking as w, setupPath as wt, tmuxWasStarted as x, ghKnownHosts as xt, sessionStates as y, discoverAgents as yt, agentFromCommand as z, run$1 as zt };