@dylanpiercey/work 0.0.71 → 0.0.72

package/dist/{_DgDsZuoQ.js → _BfXE8Kjn.js}

@@ -6332,9 +6332,15 @@ var viewers = /* @__PURE__ */ new Map();
 function summaryFromHookPayload(payload) {
 	if (!payload || typeof payload !== "object") return void 0;
 	const p = payload;
-	const text = typeof p.last_assistant_message === "string" && p.last_assistant_message || typeof p["last-assistant-message"] === "string" && p["last-assistant-message"] || typeof p.agent_message === "string" && p.agent_message || "";
+	const text = typeof p.last_assistant_message === "string" && p.last_assistant_message || typeof p["last-assistant-message"] === "string" && p["last-assistant-message"] || typeof p.lastAssistantMessage === "string" && p.lastAssistantMessage || typeof p.agent_message === "string" && p.agent_message || "";
 	if (text) return cleanSummary(text);
-	if (typeof p.notification_type === "string") return NOTIFICATION_LABELS[p.notification_type];
+	const kind = notificationType(p);
+	if (kind) {
+		const message = typeof p.message === "string" ? p.message.trim() : "";
+		return message ? cleanSummary(message) : NOTIFICATION_LABELS[kind];
+	}
+	if (typeof p.errorDetails === "string" && p.errorDetails.trim()) return cleanSummary(p.errorDetails);
+	if (typeof p.error === "string" && p.error.trim()) return cleanSummary(p.error);
 	if (p.hook_event_name === "PermissionRequest") {
 		const input = p.tool_input;
 		const what = (input && typeof input.command === "string" ? input.command : "") || (typeof p.tool_name === "string" ? p.tool_name : "");
@@ -6348,6 +6354,61 @@ var NOTIFICATION_LABELS = {
 	elicitation_dialog: "Asking a question",
 	elicitation_url_dialog: "Needs a browser sign-in"
 };
+/** Notification hooks are one channel for several kinds of event. Only some
+* mean the agent is blocked on the user; Copilot also routes shell and
+* inbox chatter through it. Those the state endpoint must drop, not paint
+* red — the notification is neither "needs input" nor "done". */
+var CHATTER_NOTIFICATIONS = /* @__PURE__ */ new Set([
+	"shell_completed",
+	"shell_detached_completed",
+	"new_inbox_message",
+	"instruction_discovered",
+	"factory_completed",
+	"unclassified"
+]);
+function ignoreHookPayload(payload) {
+	if (!payload || typeof payload !== "object") return false;
+	const p = payload;
+	const kind = notificationType(p);
+	if (kind && CHATTER_NOTIFICATIONS.has(kind)) return true;
+	if (typeof p.subagentType === "string" && p.subagentType) return true;
+	if (p.hookEventName === "stop" && typeof p.reason === "string" && p.reason !== "end_turn") return true;
+	return false;
+}
+/** `notification_type` (Claude, Copilot) or `notificationType` (Grok). */
+function notificationType(p) {
+	const kind = p.notification_type ?? p.notificationType;
+	return typeof kind === "string" ? kind : void 0;
+}
+/** Copilot's Stop payload names its transcript but not the last message;
+* the last non-empty `assistant.message` in that JSONL is it. Reads the
+* tail only — transcripts grow for the life of a session. */
+function summaryFromTranscript(payload) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const file = payload.transcript_path;
+	if (typeof file !== "string" || !file.endsWith("events.jsonl")) return void 0;
+	try {
+		const fd = fs.openSync(file, "r");
+		try {
+			const size = fs.fstatSync(fd).size;
+			const len = Math.min(size, 65536);
+			const buf = Buffer.alloc(len);
+			fs.readSync(fd, buf, 0, len, size - len);
+			const lines = buf.toString("utf8").split("\n");
+			for (let i = lines.length - 1; i >= 0; i--) {
+				const line = lines[i];
+				if (!line.includes("\"assistant.message\"")) continue;
+				try {
+					const ev = JSON.parse(line);
+					const content = ev.type === "assistant.message" ? ev.data?.content : void 0;
+					if (typeof content === "string" && content.trim()) return cleanSummary(content);
+				} catch {}
+			}
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {}
+}
 /** Notifications that mean the agent is nudging about an idle session
 * rather than blocking on one. The hook cannot tell them apart when it
 * fires — it reports every notification the same way — so the kind has to
@@ -6357,8 +6418,8 @@ var NUDGE_NOTIFICATIONS = /* @__PURE__ */ new Set(["idle_prompt"]);
 /** The reason a hook's `waiting` actually carries, given its payload. */
 function reasonFromHookPayload(payload, reported) {
 	if (reported !== "attention" || !payload || typeof payload !== "object") return reported;
-	const kind = payload.notification_type;
-	return typeof kind === "string" && NUDGE_NOTIFICATIONS.has(kind) ? "done" : reported;
+	const kind = notificationType(payload);
+	return kind && NUDGE_NOTIFICATIONS.has(kind) ? "done" : reported;
 }
 /** First meaningful line(s) of an agent message, markdown chrome stripped,
 * sized for a push notification. */
@@ -6448,7 +6509,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("./_xZfpJdQE.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_DLxkSyzt.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -6459,8 +6520,12 @@ function publishChange(sessionId) {
 * workspace or the user's global config. Claude takes an inline settings
 * JSON (--settings accepts a JSON string); Codex takes lifecycle hooks via
 * `-c` overrides, trusted through a `hooks.state` entry in the same
-* override layer (see codexHookFlags). Grok, Cursor and Copilot expose no
-* file-free hook mechanism, so their sessions get working/idle from pane
+* override layer (see codexHookFlags); Copilot mounts a plugin directory
+* that lives in work's own data dir (`--plugin-dir`, see copilotPluginDir).
+* Grok has no flag at all: its hook file also lives in work's data dir, and
+* the one thing written outside it is a line naming that file in Grok's
+* hook registry `~/.grok/hooks-paths` (see grokHooksRegistered). Cursor
+* exposes no hook mechanism, so its sessions get working/idle from pane
 * activity (see scraper.ts) and nothing else — a stopped turn and a
 * question look the same. */
 function stateCurl(state, reason) {
@@ -6472,7 +6537,122 @@ function stateCurl(state, reason) {
 * costs them the state their own hook just reported. */
 function reportsWorking(agent) {
 	const family = agentFamily(agent);
-	return family === "claude" || family === "codex";
+	return family === "claude" || family === "codex" || family === "copilot" || family === "grok" && grokHooksOk;
+}
+/** Whether Grok's hook registry took work's hook file — without it Grok
+* reports nothing and the screen has to speak for it. */
+var grokHooksOk = false;
+/** Grok hook events → state. Payloads are camelCase (hookEventName,
+* notificationType, lastAssistantMessage); agent-state.ts reads both
+* spellings. Notification is matched to the two kinds that mean a prompt is
+* on screen; Stop fires on shutdown too, with a reason the endpoint uses to
+* tell a finished turn from a closed session. */
+var GROK_HOOKS = [
+	["UserPromptSubmit", "working"],
+	["PreToolUse", "working"],
+	["PostToolUse", "working"],
+	[
+		"Notification",
+		"waiting",
+		"attention",
+		"permission_prompt|elicitation_dialog"
+	],
+	[
+		"Stop",
+		"waiting",
+		"done"
+	],
+	[
+		"StopCancelled",
+		"waiting",
+		"done"
+	],
+	[
+		"StopFailure",
+		"waiting",
+		"attention"
+	]
+];
+/** Grok discovers hooks 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 the port from env, so
+* the file never needs rewriting — and registered once. Returns false when
+* the registry cannot be written (hooks then simply don't report). */
+function grokHooksRegistered() {
+	const file = path.join(config.dataDir, "grok-hooks.json");
+	const hooks = {};
+	for (const [event, state, reason, matcher] of GROK_HOOKS) hooks[event] = [{
+		...matcher ? { matcher } : {},
+		hooks: [{
+			type: "command",
+			command: stateCurl(state, reason),
+			timeout: 5
+		}]
+	}];
+	writeIfChanged(file, JSON.stringify({ hooks }, null, 2));
+	const registry = path.join(process.env.HOME || "", ".grok", "hooks-paths");
+	try {
+		let current = "";
+		try {
+			current = fs.readFileSync(registry, "utf8");
+		} catch {}
+		if (!current.split("\n").some((line) => line.trim() === file)) {
+			fs.mkdirSync(path.dirname(registry), { recursive: true });
+			fs.appendFileSync(registry, `${current && !current.endsWith("\n") ? "\n" : ""}${file}\n`);
+		}
+		grokHooksOk = true;
+	} catch {
+		grokHooksOk = false;
+	}
+	return grokHooksOk;
+}
+/** Copilot hook events (Claude-format names, which make it emit Claude's
+* snake_case payloads: hook_event_name, notification_type…) → state.
+* Notification rather than PermissionRequest for "needs input": the latter
+* fires before Copilot's own allow rules, the former only once a prompt is
+* actually on screen. Its Stop payload has no last message; the server
+* reads it from transcript_path (see agent-state.ts). */
+var COPILOT_HOOKS = [
+	["UserPromptSubmit", "working"],
+	["PreToolUse", "working"],
+	["PostToolUse", "working"],
+	[
+		"Notification",
+		"waiting",
+		"attention"
+	],
+	[
+		"Stop",
+		"waiting",
+		"done"
+	]
+];
+/** Copilot has no flag or env for inline hooks; the file-free option is a
+* plugin directory passed with `--plugin-dir`, which loads without a trust
+* prompt. The plugin is two files kept under work's data dir and rewritten
+* only when their content changes (a stale hook would report to the wrong
+* port after a config change). Returns the directory. */
+function copilotPluginDir() {
+	const dir = path.join(config.dataDir, "copilot-plugin");
+	const hooks = {};
+	for (const [event, state, reason] of COPILOT_HOOKS) hooks[event] = [{ hooks: [{
+		type: "command",
+		command: stateCurl(state, reason)
+	}] }];
+	writeIfChanged(path.join(dir, ".claude-plugin", "plugin.json"), JSON.stringify({
+		name: "work-session-state",
+		version: "1",
+		description: "Reports this session's working / needs-input / done state to work."
+	}, null, 2));
+	writeIfChanged(path.join(dir, "hooks", "hooks.json"), JSON.stringify({ hooks }, null, 2));
+	return dir;
+}
+function writeIfChanged(file, content) {
+	try {
+		if (fs.readFileSync(file, "utf8") === content) return;
+	} catch {}
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, content);
 }
 /** Codex hook events → the state each reports. Same shape as Claude's:
 * a prompt or a tool call means working, Stop means the turn is done,
@@ -6554,6 +6734,8 @@ function agentLaunchFlags(agent) {
 		} })];
 	}
 	if (family === "codex") return codexHookFlags();
+	if (family === "copilot") return ["--plugin-dir", copilotPluginDir()];
+	if (family === "grok") grokHooksRegistered();
 	return [];
 }
 //#endregion
@@ -6903,4 +7085,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { get as $, subscribe as A, setPref as B, setScrapedPhase as C, pushPublicKey as D, deleteSubscription as E, disabledAgents as F, setupPath as G, doctor as H, enabledAgents as I, TOOLS as J, which as K, getSetting as L, subscriberJoins as M, agentChoices as N, saveSubscription as O, allPrefs as P, db as Q, preferredAgent as R, setAgentPhase as S, summaryFromHookPayload as T, ghKnownHosts as U, setSetting as V, miseVersions as W, toolById as X, agentById as Y, all as Z, tmuxName as _, ensureTmuxServer as a, tmux as at, clearAgentPhase as b, killWorkspaceSessions as c, newSessionArgs as d, workspacePath as et, notifySessionsChanged as f, sessionStates as g, sendToSession as h, disposeSessions as i, run$1 as it, subscriberCount as j, publish as k, listSessions as l, renameSession as m, clearTmuxStarted as n, gh as nt, getSession as o, config as ot, panePids as p, DEFAULT_GITHUB_HOST as q, createSession as r, git as rt, killSession as s, cleanEnv as t, TMUX_SOCKET as tt, markTmuxStarted as u, tmuxWasStarted as v, setSessionViewers as w, reasonFromHookPayload as x, reportsWorking as y, setDisabledAgents as z };
+export { all as $, saveSubscription as A, preferredAgent as B, setAgentPhase as C, summaryFromTranscript as D, summaryFromHookPayload as E, agentChoices as F, ghKnownHosts as G, setPref as H, allPrefs as I, which as J, miseVersions as K, disabledAgents as L, subscribe as M, subscriberCount as N, deleteSubscription as O, subscriberJoins as P, toolById as Q, enabledAgents as R, reasonFromHookPayload as S, setSessionViewers as T, setSetting as U, setDisabledAgents as V, doctor as W, TOOLS as X, DEFAULT_GITHUB_HOST as Y, agentById as Z, tmuxName as _, ensureTmuxServer as a, git as at, clearAgentPhase as b, killWorkspaceSessions as c, config as ct, newSessionArgs as d, db as et, notifySessionsChanged as f, sessionStates as g, sendToSession as h, disposeSessions as i, gh as it, publish as j, pushPublicKey as k, listSessions as l, renameSession as m, clearTmuxStarted as n, workspacePath as nt, getSession as o, run$1 as ot, panePids as p, setupPath as q, createSession as r, TMUX_SOCKET as rt, killSession as s, tmux as st, cleanEnv as t, get as tt, markTmuxStarted as u, tmuxWasStarted as v, setScrapedPhase as w, ignoreHookPayload as x, reportsWorking as y, getSetting as z };

package/dist/_DLxkSyzt.js

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