@dylanpiercey/work 0.0.140 → 0.0.142

package/dist/{_BXzfMZ_J.js → _CgMVRC4h.js}

@@ -6501,21 +6501,24 @@ var viewers = /* @__PURE__ */ new Map();
 function setAgentPhase(sessionId, phase, reason, summary) {
 	if (phase === "waiting" && reason === "done") {
 		if (summary) summaries.set(sessionId, summary);
-		if (Date.now() - bootedAt > BOOT_GRACE_MS) notify(sessionId, "done");
+		notify(sessionId, "done");
 		if (phases.has(sessionId)) applyChange(sessionId, () => {
 			phases.delete(sessionId);
 			reasons.delete(sessionId);
-		});
+		}, true);
 		return;
 	}
 	if (phase === "waiting" && summary) summaries.set(sessionId, summary);
-	else if (phase === "working") summaries.delete(sessionId);
+	else if (phase === "working") {
+		summaries.delete(sessionId);
+		reasons.delete(sessionId);
+	}
 	const next = phase === "waiting" && reason ? reason : reasons.get(sessionId);
 	if (phases.get(sessionId) === phase && reasons.get(sessionId) === next) return;
 	applyChange(sessionId, () => {
 		phases.set(sessionId, phase);
 		if (phase === "waiting" && reason) reasons.set(sessionId, reason);
-	});
+	}, true);
 }
 /** Live visible-terminal count per session, reported by the term server;
 * a session someone is watching does not push notifications. */
@@ -6564,23 +6567,26 @@ function clearAgentPhase(sessionId) {
 function agentPhase(sessionId) {
 	return phases.get(sessionId) ?? scraped.get(sessionId);
 }
-/** Freshly booted servers re-discover already-waiting sessions on the
-* first scan — that must not re-buzz every device after a deploy. */
+/** A freshly booted server's first scans re-derive scraped state from
+* panes that were already that way — that must not re-buzz every device
+* after a deploy. Hook reports are exempt: each is a real transition the
+* agent just made, and one that lands right after a restart (the turn
+* that was running through it) is exactly the one worth hearing about. */
 var BOOT_GRACE_MS = 15e3;
 var bootedAt = Date.now();
-function applyChange(sessionId, mutate) {
+function applyChange(sessionId, mutate, fromHook = false) {
 	const before = agentPhase(sessionId);
 	mutate();
 	const after = agentPhase(sessionId);
 	if (before === after) return;
 	publishChange(sessionId);
-	if (after === "waiting" && before !== "waiting" && Date.now() - bootedAt > BOOT_GRACE_MS) notify(sessionId, reasons.get(sessionId) ?? "attention");
+	if (after === "waiting" && before !== "waiting" && (fromHook || Date.now() - bootedAt > BOOT_GRACE_MS)) notify(sessionId, reasons.get(sessionId) ?? "attention");
 }
 function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_D2thrkJX.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_CwAYWKgO.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -6593,33 +6599,33 @@ function publishChange(sessionId) {
 * come from the env tmux gave the pane (see sessions.ts). */
 function stateCurl(state, reason) {
 	const qs = `session=$WORK_SESSION_ID&state=${state}` + (reason ? `&reason=${reason}` : "");
-	return `[ -n "$WORK_SESSION_ID" ] && curl -sf -m 3 -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 -m 2 --retry 2 --retry-delay 1 --retry-connrefused -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`;
 }
 /** Claude-format hook groups (`{matcher?, hooks:[{type:"command",command}]}`)
 * for a hook map — the JSON shape Claude, Copilot plugins and Grok all read. */
 function claudeStyleHooks(map, extra = {}) {
 	const hooks = {};
-	for (const [event, state, reason, matcher] of map) hooks[event] = [{
+	for (const [event, state, reason, matcher] of map) (hooks[event] ??= []).push({
 		...matcher ? { matcher } : {},
 		hooks: [{
 			type: "command",
 			command: stateCurl(state, reason),
 			...extra
 		}]
-	}];
+	});
 	return hooks;
 }
 var NOTIFICATION_LABELS = {
 	permission_prompt: "Waiting for permission",
-	idle_prompt: "Waiting for your reply",
 	agent_needs_input: "Waiting for input",
 	elicitation_dialog: "Asking a question",
 	elicitation_url_dialog: "Needs a browser sign-in"
 };
 /** Notifications that mean the agent is nudging about an idle session
-* rather than blocking on one: the hook reports every notification the
-* same way, so the kind has to come out of the payload, or a session that
-* merely sat there reads as stuck and paints the nav red. */
+* rather than blocking on one. Stop already said the turn ended and
+* pushed for it; reporting the nudge too painted the nav red for a
+* session that merely sat there, and — read as "done" — buzzed a second
+* time a minute after every finish. Dropped entirely. */
 var NUDGE_NOTIFICATIONS = /* @__PURE__ */ new Set(["idle_prompt"]);
 function str$1(v) {
 	return typeof v === "string" ? v.trim() : "";
@@ -6630,11 +6636,12 @@ function notificationType(p) {
 }
 /** Read a Claude-format payload: last message on Stop, the CLI's own
 * notification line (or a label for its type) on Notification, and the
-* idle nudge downgraded to done. Families that speak this dialect start
-* here and add their own quirks. */
+* idle nudge dropped. Families that speak this dialect start here and
+* add their own quirks. */
 function readClaudeStyle(p, reported) {
 	const kind = notificationType(p);
-	const reason = reported === "attention" && NUDGE_NOTIFICATIONS.has(kind) ? "done" : reported;
+	if (NUDGE_NOTIFICATIONS.has(kind)) return { ignore: true };
+	const reason = reported;
 	const text = str$1(p.last_assistant_message) || str$1(p["last-assistant-message"]) || str$1(p.lastAssistantMessage);
 	if (text) return {
 		reason,
@@ -7147,15 +7154,46 @@ async function claudeRow(account) {
 	const fallback = loaded.payload ? null : claudeJsonFallback(account);
 	return markStale(parseRow$4(account, loaded.payload ?? fallback, fallback ? "claude.json" : loaded.source), account.label, tokenExpired(account), loaded.reason);
 }
+//#endregion
+//#region src/agents/claude/index.ts
+var meta$6 = meta_default$6;
+/** The tool Claude asks the user a question with. Its prompt is a wait
+* like any other, but the turn has not ended, so no Stop or Notification
+* says so — PreToolUse on this tool is the only signal, and PostToolUse
+* (the answer arrived) clears it. */
+var QUESTION_TOOL = "AskUserQuestion";
+/** Claude's dialect plus the question tool's prompt text. */
+function readHook$4(p, reported) {
+	const read = readClaudeStyle(p, reported);
+	if (read.ignore) return read;
+	if (p.hook_event_name === "PreToolUse" && p.tool_name === QUESTION_TOOL) {
+		const input = p.tool_input;
+		const q = str$1(input?.questions?.[0]?.question);
+		read.summary = q ? cleanSummary(q) : "Asking a question";
+	}
+	return read;
+}
 /** Claude Code takes its settings inline (`--settings` accepts a JSON
 * string), so the hooks travel in argv and nothing is written anywhere.
 * Its Notification hook fires for permission prompts and questions —
-* and for the idle nudge, which readClaudeStyle downgrades. */
+* and for the idle nudge, which readClaudeStyle drops. */
 var claude = {
-	meta: meta_default$6,
+	meta: meta$6,
 	launchFlags: () => ["--settings", JSON.stringify({ hooks: claudeStyleHooks([
 		["UserPromptSubmit", "working"],
-		["PreToolUse", "working"],
+		[
+			"PreToolUse",
+			"working",
+			void 0,
+			`^(?!${QUESTION_TOOL}$)`
+		],
+		[
+			"PreToolUse",
+			"waiting",
+			"attention",
+			`^${QUESTION_TOOL}$`
+		],
+		["PostToolUse", "working"],
 		[
 			"Stop",
 			"waiting",
@@ -7173,7 +7211,7 @@ var claude = {
 		"CLAUDECODE",
 		"AI_AGENT"
 	],
-	readHook: readClaudeStyle,
+	readHook: readHook$4,
 	usage: () => Promise.all(claudeAccounts().map((account) => claudeRow(account)))
 };
 //#endregion
@@ -7530,9 +7568,19 @@ 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()],
+	startupPrompt,
 	reportsWorking: () => true,
 	envPrefixes: ["COPILOT_"],
 	readHook: readHook$2,
@@ -7651,6 +7699,7 @@ async function cursorRow() {
 * nothing else — a stopped turn and a question look the same. */
 var cursor = {
 	meta: meta_default$3,
+	readyScreen: /Plan, search, build anything|Add a follow-up/,
 	usage: () => cursorRow().then((row) => [row])
 };
 //#endregion
@@ -7787,9 +7836,21 @@ var HOOKS = claudeStyleHooks([
 		"attention"
 	]
 ], { timeout: 5 });
-/** Whether Grok's hook registry took work's hook file — without it Grok
-* reports nothing and the screen has to speak for it. */
-var registered = false;
+var HOOK_FILE = () => path.join(config.dataDir, "grok-hooks.json");
+var REGISTRY = () => path.join(process.env.HOME || "", ".grok", "hooks-paths");
+/** Whether Grok's hook registry names work's hook file — without it Grok
+* reports nothing and the screen has to speak for it. Read from disk, not
+* remembered from a launch: a session that outlives the app process still
+* has its hooks, and a flag reset by the restart would put the scraper
+* back on a session that reports for itself. */
+function registered() {
+	try {
+		const file = HOOK_FILE();
+		return fs.readFileSync(REGISTRY(), "utf8").split("\n").some((line) => line.trim() === file);
+	} catch {
+		return false;
+	}
+}
 /** Grok has no flag for hooks. It discovers them from `~/.grok/hooks-paths`:
 * one absolute path per line, the registry its own `/hooks-add` command
 * appends to. work's hook file is kept in the data dir — the commands read
@@ -7797,9 +7858,9 @@ var registered = false;
 * once. The one line in that registry is the only thing work writes
 * outside its own dir for any agent. */
 function registerHooks() {
-	const file = path.join(config.dataDir, "grok-hooks.json");
+	const file = HOOK_FILE();
 	writeIfChanged(file, JSON.stringify({ hooks: HOOKS }, null, 2));
-	const registry = path.join(process.env.HOME || "", ".grok", "hooks-paths");
+	const registry = REGISTRY();
 	try {
 		let current = "";
 		try {
@@ -7809,11 +7870,7 @@ function registerHooks() {
 			fs.mkdirSync(path.dirname(registry), { recursive: true });
 			fs.appendFileSync(registry, `${current && !current.endsWith("\n") ? "\n" : ""}${file}\n`);
 		}
-		registered = true;
-	} catch {
-		registered = false;
-	}
-	return registered;
+	} catch {}
 }
 function readHook$1(p, reported) {
 	if (str$1(p.subagentType)) return { ignore: true };
@@ -7831,7 +7888,7 @@ var grok = {
 		registerHooks();
 		return [];
 	},
-	reportsWorking: () => registered,
+	reportsWorking: registered,
 	promptAsArgv: true,
 	envPrefixes: ["GROK_"],
 	readHook: readHook$1,
@@ -7919,21 +7976,23 @@ export const WorkSessionState = async () => {
   };
 };
 `;
+var PLUGIN_FILE = () => path.join(config.dataDir, "opencode-plugin.js");
 /** Whether the plugin is on disk for opencode to load — without it the
-* screen has to speak for the session. */
-var installed = false;
+* screen has to speak for the session. Checked on disk rather than
+* remembered from a launch, so a session that outlives the app process
+* is still known to report for itself. */
+function installed() {
+	return fs.existsSync(PLUGIN_FILE());
+}
 /** opencode resolves a `plugin` entry that looks like a path as a local
 * file, and reads `OPENCODE_CONFIG_CONTENT` as one more config layer that
 * merges over the user's own. Together that loads work's plugin from
 * work's data dir without writing a line into ~/.config/opencode. */
 function pluginConfig() {
-	const file = path.join(config.dataDir, "opencode-plugin.js");
+	const file = PLUGIN_FILE();
 	try {
 		writeIfChanged(file, PLUGIN(config.appPort));
-		installed = true;
-	} catch {
-		installed = false;
-	}
+	} catch {}
 	return JSON.stringify({ plugin: [file] });
 }
 function readHook(p, reported) {
@@ -7956,8 +8015,9 @@ var AGENTS = [
 	grok,
 	{
 		meta: meta$1,
+		readyScreen: /Ask anything/,
 		launchEnv: () => ({ OPENCODE_CONFIG_CONTENT: pluginConfig() }),
-		reportsWorking: () => installed,
+		reportsWorking: installed,
 		envPrefixes: ["OPENCODE_"],
 		readHook
 	},
@@ -7986,6 +8046,14 @@ function agentLaunchEnv(id) {
 function reportsWorking(id) {
 	return agentFor(id)?.reportsWorking?.() ?? false;
 }
+/** Keys that answer whatever startup prompt the CLI is showing, if any. */
+function startupPromptKeys(id, screen) {
+	return agentFor(id)?.startupPrompt?.(screen);
+}
+/** The input-box marker for CLIs whose splash looks settled early. */
+function readyScreen(id) {
+	return agentFor(id)?.readyScreen;
+}
 /** Cold launch takes the first prompt as argv rather than a paste. */
 function promptAsArgv(id) {
 	return agentFor(id)?.promptAsArgv ?? false;
@@ -8105,7 +8173,7 @@ async function sendToSession(id, text, size) {
 		}
 		await tmux(newSessionArgs(session, wsPath, "-d", void 0, size), env);
 		markTmuxStarted(id);
-		await sleep(AGENT_BOOT_MS);
+		await waitForAgent(name, env, session.agent);
 	}
 	const buffer = `work-send-${Math.random().toString(36).slice(2, 8)}`;
 	await tmux([
@@ -8123,7 +8191,7 @@ async function sendToSession(id, text, size) {
 		"-t",
 		name
 	], env);
-	await sleep(PASTE_SETTLE_MS);
+	await waitStill(name, env, PASTE_SETTLE_MS);
 	await tmux([
 		"send-keys",
 		"-t",
@@ -8351,8 +8419,73 @@ function cleanEnv() {
 	env.PATH = [...parts, ...bins.filter((bin) => !parts.includes(bin))].join(":");
 	return forceUtf8Locale(env);
 }
-var AGENT_BOOT_MS = 1500;
-var PASTE_SETTLE_MS = 150;
+/** 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;
+/** A drawn screen that has not changed for this long is a TUI at rest. */
+var SCREEN_STILL_MS = 600;
+/** Resolve once the agent is the pane's foreground process and has drawn
+* a screen that then held still — opencode is foreground in 0.4 s and
+* paints its prompt at 2.4 s; Claude is ready in about a second. */
+async function waitForAgent(name, env, agent) {
+	const until = Date.now() + AGENT_BOOT_MS;
+	while (Date.now() < until) {
+		const c = (await tmux([
+			"display",
+			"-p",
+			"-t",
+			name,
+			"#{pane_current_command}"
+		], env).catch(() => "")).trim();
+		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);
+	}
+}
+/** Resolve once the pane has drawn something and then held still for
+* SCREEN_STILL_MS, or after `maxMs` (a TUI with an animation never
+* settles; a blank pane never draws). */
+async function waitStill(name, env, maxMs, ready) {
+	const until = Date.now() + Math.max(0, maxMs);
+	let last = "";
+	let stillSince = 0;
+	while (Date.now() < until) {
+		const drawn = (await tmux([
+			"capture-pane",
+			"-p",
+			"-t",
+			name
+		], env).catch(() => "")).trim();
+		if (drawn && (!ready || ready.test(drawn))) {
+			if (drawn === last) {
+				if (Date.now() - stillSince >= SCREEN_STILL_MS) return;
+			} else {
+				last = drawn;
+				stillSince = Date.now();
+			}
+		}
+		await sleep(150);
+	}
+}
+/** Upper bound on the pasted text settling on screen before Enter. */
+var PASTE_SETTLE_MS = 2500;
 /** Command for a session kind: the instance's binary (`claude2`,
 * `cursor-agent`), nothing for `shell`; `command.<agent>` in settings still
 * overrides for one-off wrappers.

package/dist/_CwAYWKgO.js

@@ -0,0 +1,2 @@
+import { f as notifySessionsChanged } from "./_CgMVRC4h.js";
+export { notifySessionsChanged };