@dylanpiercey/work 0.2.18 → 0.2.19

package/README.md

@@ -59,7 +59,10 @@ work-source                # status
 Everything the app's pages do has a `work` command too, so an agent — or a
 script — can use and set up work from a terminal: `work help` lists them.
 Inside a workspace, `work branches`, `work session`, `work topic`,
-`work review`, `work notify` and `work open`; to change things,
+`work review`, `work notify` and `work open`; agents start and message each
+other with `work session new|send|wait` — any vendor's, each in a tab of its
+own the user watches, its last message as a turn ends coming back to the
+one that asked as a prompt; to change things,
 `work workspace create`, `work repo add`, `work config get|set` (checked
 against what each setting takes; `work config schema` lists them),
 `work agent|skill|lsp|host` and `work gh login`; `work status` sums the

package/bin/cli/session.mjs

@@ -1,6 +1,7 @@
 // `work session`: which session this is (an agent's own pane, by
 // WORK_SESSION_ID), its name in the session list, and the workspace's
-// other sessions — starting one, sending it a prompt, closing it.
+// other sessions — starting one, messaging it and waiting on its reply,
+// closing it (server/messages.ts).
 
 /** More sessions than this in one workspace is an agent starting them in
  * a loop, not a plan: past it, `new` wants --force. */
@@ -16,21 +17,84 @@ function sessionId(ctx) {
   return id;
 }
 
-/** The workspace's sessions with their state, this pane's marked. */
+/** How long `wait` waits by default: inside an agent's own tool limit
+ * (ten minutes for most), so it ends saying who is still working rather
+ * than being killed. */
+const WAIT_S = 540;
+const POLL_MS = 1500;
+
+/** The workspace's sessions with their state, this pane's marked, each
+ * after the session that started it (as the sidebar lists them). */
 async function sessionsOf(ctx, wsId) {
   const me = process.env.WORK_SESSION_ID;
   const list = await ctx.api.get(`/api/workspaces/${wsId}/sessions`);
-  return list.map((s) => ({
+  const rows = list.map((s) => ({
     id: s.id,
     agent: s.agent,
     title: s.title || null,
     phase: s.state?.phase || (s.state?.alive ? "idle" : "off"),
+    parent: s.parent_id || null,
+    waitingOn: s.messages?.waitingOn ?? [],
+    queued: s.messages?.queued ?? 0,
     self: s.id === me,
   }));
+  const ids = new Set(rows.map((s) => s.id));
+  const out = [];
+  const walk = (s, depth) => {
+    if (out.some((o) => o.id === s.id)) return;
+    out.push({ ...s, depth });
+    for (const c of rows) if (c.parent === s.id) walk(c, depth + 1);
+  };
+  for (const s of rows) if (!s.parent || !ids.has(s.parent)) walk(s, 0);
+  for (const s of rows) walk(s, 0);
+  return out;
 }
 
 function sessionLine(ctx, s) {
-  return `${ctx.pad(s.id, 9)} ${ctx.pad(s.agent, 10)} ${ctx.pad(s.phase, 8)} ${s.title || ""}${s.self ? "  (this session)" : ""}`;
+  const notes = [
+    s.waitingOn.length && `waiting on ${s.waitingOn.join(", ")}`,
+    s.queued && `${s.queued} queued for it`,
+    s.self && "this session",
+  ].filter(Boolean);
+  return `${"  ".repeat(s.depth ?? 0)}${ctx.pad(s.id, 9)} ${ctx.pad(s.agent, 10)} ${ctx.pad(s.phase, 8)} ${s.title || ""}${notes.length ? `  (${notes.join("; ")})` : ""}`;
+}
+
+/** A flag's value, "-" (stdin) included, which ctx.flag takes for a
+ * flag of its own. */
+function valueOf(ctx, flag) {
+  const i = ctx.args.indexOf(flag);
+  if (i >= 0 && ctx.args[i + 1] === "-") return "-";
+  return ctx.flag(flag);
+}
+
+/** The text itself, or stdin's for "-": a heredoc carries a long prompt
+ * with quotes in it, which an argument mangles. */
+async function textOf(value) {
+  if (value !== "-") return value;
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8").replace(/\n$/, "");
+}
+
+/** What became of a message, for the sender. */
+function sentText(id, r) {
+  const lines = [
+    r.delivered
+      ? `sent to ${id}`
+      : `queued for ${id} (${r.queued}): typed in once it is at its prompt`,
+  ];
+  if (r.wantsReply)
+    lines.push(
+      `Its last message, as that turn ends, comes back to you as a prompt: end your turn to wait for it, or run \`work session wait ${id}\`.`,
+    );
+  return lines.join("\n");
+}
+
+function printReply(r) {
+  const head =
+    r.kind === "reply" ? `${r.label} replied:` : `${r.label}: ${r.text}`;
+  console.log(head);
+  if (r.kind === "reply") console.log(`${r.text}\n`);
 }
 
 export const commands = [
@@ -44,14 +108,26 @@ work session list [id|name] [--json]
   The workspace's sessions, this one marked.
 work session title "<name>" [--session <id>]
   Name a session in the session list (empty clears it).
-work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"] [--workspace <id|name>] [--force]
-  Start a session (the default agent unless --agent; "shell" for a
-  terminal), name it, and hand it a first prompt. Past ${SESSION_CAP} sessions
-  in the workspace it wants --force.
-work session send <id> "<text>"
-  Type text into a session and press Enter, as the review's Send does.
+work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"|-] [--no-reply] [--workspace <id|name>] [--force]
+  Start a session (the default agent unless --agent, any vendor's; "shell"
+  for a terminal) in a tab of its own, where the user watches it, name it,
+  and hand it a first prompt ("-": read it from stdin). Started from
+  another session it is listed under that one, and the prompt is a
+  message from it (below). Past ${SESSION_CAP} sessions in the workspace it wants --force.
+work session send <id> "<text>"|- [--no-reply]
+  Message an agent session: typed in, headed with who it is from, once
+  it is at its prompt — never into a turn under way, a question it asks,
+  or a draft someone is typing. From an agent's session it wants a reply
+  unless --no-reply: the recipient's last message as that turn ends,
+  typed into this session as a prompt of its own. End your turn to wait
+  for it. A file's path says more than its text pasted in.
+work session wait [<id>...] [--timeout <seconds>]
+  Wait for the replies owed to this session (by those sessions, else by
+  any), printing each as it comes; a reply printed here is not typed in
+  too. Exits 124 if some are still working after --timeout (${WAIT_S} s).
 work session kill <id> --yes
-  Close a session and the process in it.`,
+  Close a session and the process in it (whoever waits on its reply is
+  told).`,
     async run(ctx) {
       const [verb, ...rest] = ctx.parse([
         "--agent",
@@ -59,6 +135,7 @@ work session kill <id> --yes
         "--prompt",
         "--workspace",
         "--session",
+        "--timeout",
       ]);
       switch (verb) {
         case undefined: {
@@ -68,6 +145,7 @@ work session kill <id> --yes
           if (!me) ctx.die(`no session ${id} in ${ws.name}`);
           const out = {
             ...me,
+            depth: undefined,
             workspace: {
               id: ws.id,
               name: ws.name,
@@ -77,7 +155,7 @@ work session kill <id> --yes
           };
           return ctx.out(out, (s) => {
             console.log(
-              `${s.id}  ${s.agent}  ${s.phase}${s.title ? `  "${s.title}"` : ""}`,
+              `${s.id}  ${s.agent}  ${s.phase}${s.title ? `  "${s.title}"` : ""}${s.waitingOn.length ? `  (waiting on ${s.waitingOn.join(", ")})` : ""}`,
             );
             console.log(
               `workspace ${s.workspace.name} (${s.workspace.id})  ${s.workspace.path}`,
@@ -110,42 +188,93 @@ work session kill <id> --yes
               `${ws.name} already has ${existing.length} sessions: pass --force to start another`,
             );
           const agent = ctx.flag("--agent");
+          const me = process.env.WORK_SESSION_ID;
+          const prompt = await textOf(valueOf(ctx, "--prompt"));
           const created = await ctx.api.post(
             `/api/workspaces/${ws.id}/sessions`,
-            agent ? { agent } : {},
+            { ...(agent ? { agent } : {}), ...(me ? { parent: me } : {}) },
           );
           const title = ctx.flag("--title");
           if (title)
             await ctx.api.patch(`/api/sessions/${created.id}`, { title });
-          const prompt = ctx.flag("--prompt");
           // Sent, the session starts (detached) with it as its first
           // prompt; otherwise it starts when someone opens it.
-          if (prompt)
-            await ctx.api.post(`/api/sessions/${created.id}/send`, {
-              text: prompt,
-            });
+          const sent = prompt
+            ? await ctx.api.post(`/api/sessions/${created.id}/messages`, {
+                text: prompt,
+                ...(me ? { from: me } : {}),
+                reply: !ctx.has("--no-reply"),
+              })
+            : null;
           const out = {
             id: created.id,
             agent: created.agent,
             title: title || null,
             workspace: ws.id,
-            prompted: !!prompt,
+            parent: created.parent_id ?? null,
+            prompted: !!sent?.delivered,
+            queued: sent?.queued ?? null,
+            wantsReply: !!sent?.wantsReply,
             href: `/w/${ws.id}?s=${created.id}`,
           };
-          return ctx.out(out, (s) =>
+          return ctx.out(out, (s) => {
             console.log(
               `started ${s.id} (${s.agent})${s.prompted ? " with its prompt" : ""}: [${s.title || s.agent}](${s.href})`,
-            ),
-          );
+            );
+            if (s.queued)
+              console.log(`its prompt waits to be typed in: ${s.queued}`);
+            if (s.wantsReply)
+              console.log(
+                `Its last message, as that turn ends, comes back to you as a prompt: end your turn to wait for it, or run \`work session wait ${s.id}\`.`,
+              );
+          });
         }
         case "send": {
           const [id, ...words] = rest;
-          const text = words.join(" ");
-          if (!id || !text) ctx.die('usage: work session send <id> "<text>"');
-          await ctx.api.post(`/api/sessions/${id}/send`, { text });
-          return ctx.out({ id, sent: true }, () =>
-            console.log(`sent to ${id}`),
-          );
+          const text = await textOf(words.join(" "));
+          if (!id || !text)
+            ctx.die('usage: work session send <id> "<text>"|- [--no-reply]');
+          const me = process.env.WORK_SESSION_ID;
+          const r = await ctx.api.post(`/api/sessions/${id}/messages`, {
+            text,
+            ...(me ? { from: me } : {}),
+            reply: !ctx.has("--no-reply"),
+          });
+          return ctx.out({ id, ...r }, (r) => console.log(sentText(id, r)));
+        }
+        case "wait": {
+          const me = sessionId(ctx);
+          const raw = ctx.flag("--timeout");
+          const seconds = raw === undefined ? WAIT_S : Number(raw);
+          if (!Number.isFinite(seconds) || seconds < 0)
+            ctx.die("--timeout is a number of seconds");
+          const until = Date.now() + seconds * 1000;
+          const body = rest.length ? { from: rest } : {};
+          const replies = [];
+          let owing = [];
+          for (;;) {
+            const r = await ctx.api.post(`/api/sessions/${me}/replies`, body);
+            replies.push(...r.replies);
+            if (!ctx.json) r.replies.forEach(printReply);
+            owing = r.owing;
+            if (!owing.length || Date.now() >= until) break;
+            await new Promise((res) => setTimeout(res, POLL_MS));
+          }
+          if (ctx.json)
+            console.log(JSON.stringify({ replies, owing }, null, 2));
+          else if (!replies.length && !owing.length)
+            console.log(
+              rest.length
+                ? `nothing owed by ${rest.join(", ")}: a reply already typed in is in your prompt`
+                : "no session owes this one a reply",
+            );
+          if (owing.length) {
+            ctx.warn(
+              `still working: ${owing.map((o) => o.label).join(", ")} (wait again, or end your turn: the reply comes as a prompt)`,
+            );
+            process.exitCode = 124;
+          }
+          return;
         }
         case "kill": {
           const [id] = rest;

package/bin/work.mjs

@@ -133,7 +133,9 @@ const cli = await cliCommand(command, positional[0]);
 
 switch (cli ? "" : command) {
   case "":
-    await cli.cmd.run(cliContext(cli.words));
+    // `work session --help` is what an agent tries before `work help`.
+    if (args.includes("--help") || args.includes("-h")) await helpCmd(command);
+    else await cli.cmd.run(cliContext(cli.words));
     break;
   case "help":
   case "--help":
@@ -285,6 +287,13 @@ async function apiCall(method, path, body, timeoutMs = 30_000) {
       signal: AbortSignal.timeout(timeoutMs),
     });
   } catch {
+    // Codex runs commands in a sandbox with no network, a local socket
+    // included: the server is up, the command has to run outside it,
+    // which the agent asks the user for.
+    if (process.env.CODEX_SANDBOX_NETWORK_DISABLED)
+      die(
+        "work cannot reach its server from inside Codex's sandbox (no network there): run this command outside the sandbox, with escalated permissions",
+      );
     die(`no work server on port ${port}. Start one with: work start`);
   }
   const text = await res.text();

package/dist/{_BlLEM8du.js → _CsokArOR.js}

@@ -478,6 +478,30 @@ var STEPS = [
 		up(db) {
 			db.exec("DELETE FROM settings WHERE key = 'ui.term-predict'");
 		}
+	},
+	{
+		version: 4,
+		name: "session messages",
+		up(db) {
+			db.exec(`
+        ALTER TABLE sessions ADD COLUMN parent_id TEXT REFERENCES sessions(id) ON DELETE SET NULL;
+
+        CREATE TABLE session_messages (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          to_session TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          from_session TEXT,
+          from_label TEXT,
+          kind TEXT NOT NULL CHECK (kind IN ('message', 'reply', 'closed')),
+          body TEXT NOT NULL,
+          wants_reply INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          delivered_at TEXT
+        );
+
+        CREATE INDEX session_messages_to ON session_messages(to_session);
+        CREATE INDEX session_messages_from ON session_messages(from_session);
+      `);
+		}
 	}
 ];
 var LATEST = STEPS.at(-1).version;
@@ -8215,6 +8239,18 @@ var interruptedAt = /* @__PURE__ */ new Map();
 * finished: the session is working until a turn ends with none left, and
 * that end is the one pushed. */
 var background = /* @__PURE__ */ new Map();
+/** Each session's last finished turn's message, whole: what a session
+* that messaged it gets back (server/messages). */
+var lastMessages = /* @__PURE__ */ new Map();
+/** Sessions a message is still to wake (server/messages keeps the set):
+* each asked another something not yet answered, or has one waiting to
+* be typed in. Like background work, that makes the session working, and
+* a turn of it that ends meanwhile has handed off rather than finished. */
+var expecting = /* @__PURE__ */ new Set();
+/** When someone last typed into each session's pane from a page. */
+var typedAt = /* @__PURE__ */ new Map();
+/** Told of each turn's end that stayed the end (`onTurnEnd`). */
+var turnEndListeners = /* @__PURE__ */ new Set();
 /** 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
@@ -8225,7 +8261,7 @@ var listeners = /* @__PURE__ */ new Set();
 function onPhaseChange(fn) {
 	listeners.add(fn);
 }
-function setAgentPhase(sessionId, phase, reason, summary) {
+function setAgentPhase(sessionId, phase, reason, summary, message) {
 	reportedAt.set(sessionId, Date.now());
 	cancelDone(sessionId);
 	if (phase === "idle") {
@@ -8235,10 +8271,13 @@ function setAgentPhase(sessionId, phase, reason, summary) {
 	if (phase === "waiting" && reason === "done") {
 		const failed = phases.get(sessionId) === "waiting" && reasons.get(sessionId) === "attention";
 		if (summary) summaries.set(sessionId, summary);
+		if (message) lastMessages.set(sessionId, message);
+		else lastMessages.delete(sessionId);
 		if (phases.has(sessionId)) applyChange(sessionId, () => dropHook(sessionId));
-		if (!failed && !background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
+		if (!background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
 			pendingDone.delete(sessionId);
-			notify(sessionId, "done");
+			const answered = endTurn(sessionId);
+			if (!failed && !answered && !expecting.has(sessionId)) notify(sessionId, "done");
 		}, DONE_SETTLE_MS));
 		return;
 	}
@@ -8273,6 +8312,39 @@ function noteBackground(sessionId, work) {
 		else background.delete(sessionId);
 	});
 }
+/** A turn's end once it has stayed the end (`DONE_SETTLE_MS`), with its
+* last message (undefined: the CLI reports none). A listener returns
+* whether it passed the end on to another session. */
+function onTurnEnd(fn) {
+	turnEndListeners.add(fn);
+}
+function endTurn(sessionId) {
+	let told = false;
+	for (const fn of turnEndListeners) told = fn(sessionId, lastMessages.get(sessionId)) || told;
+	return told;
+}
+/** A turn's end still waiting out `DONE_SETTLE_MS`: it may yet carry on. */
+function turnSettling(sessionId) {
+	return pendingDone.has(sessionId);
+}
+/** The sessions a message is still to wake (server/messages). */
+function setExpecting(ids) {
+	for (const id of /* @__PURE__ */ new Set([...expecting, ...ids])) {
+		if (expecting.has(id) === ids.has(id)) continue;
+		applyChange(id, () => {
+			if (ids.has(id)) expecting.add(id);
+			else expecting.delete(id);
+		});
+	}
+}
+/** Someone typed into the session's pane from a page. */
+function noteTyped(sessionId) {
+	typedAt.set(sessionId, Date.now());
+}
+/** When someone last typed into the session's pane (0: not this run). */
+function lastTypedAt(sessionId) {
+	return typedAt.get(sessionId) ?? 0;
+}
 function cancelDone(sessionId) {
 	const timer = pendingDone.get(sessionId);
 	if (!timer) return;
@@ -8377,6 +8449,8 @@ async function notify(sessionId, reason) {
 function clearAgentPhase(sessionId) {
 	cancelDone(sessionId);
 	summaries.delete(sessionId);
+	lastMessages.delete(sessionId);
+	typedAt.delete(sessionId);
 	reportedAt.delete(sessionId);
 	interruptedAt.delete(sessionId);
 	if (!phases.has(sessionId) && !scraped.has(sessionId) && !background.has(sessionId)) return;
@@ -8387,11 +8461,17 @@ function clearAgentPhase(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) {
+/** What a session's own turn is doing. The hook wins where there is one:
+* it reports the turn itself, where tmux only sees the pane still moving
+* after it. Undefined: at its prompt, where a message can be typed in. */
+function turnPhase(sessionId) {
 	return hookPhase(sessionId) ?? scraped.get(sessionId);
 }
+/** What a session is doing: its turn, else working while a message is
+* still to wake it — a session that handed work to another is not done. */
+function agentPhase(sessionId) {
+	return turnPhase(sessionId) ?? (expecting.has(sessionId) ? "working" : void 0);
+}
 /** Apply a mutation and broadcast when it moved the session's phase (or,
 * `force`, its reason: finished and blocked draw differently). Only a
 * hook ever reports "waiting", so a transition into it is a push. */
@@ -8408,7 +8488,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("./_t9VsALwo.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_L2HNAA_8.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -8472,7 +8552,8 @@ function readClaudeStyle(p, reported) {
 	const text = str$1(p.last_assistant_message) || str$1(p["last-assistant-message"]) || str$1(p.lastAssistantMessage);
 	if (text) return {
 		reason,
-		summary: cleanSummary(text)
+		summary: cleanSummary(text),
+		message: text
 	};
 	if (kind) return {
 		reason,
@@ -9503,7 +9584,10 @@ function readHook$4(p, reported, _state) {
 		};
 	}
 	const read = readClaudeStyle(p, reported);
-	if (!read.summary && reported === "done") read.summary = lastMessageFromTranscript(p);
+	if (!read.summary && reported === "done") {
+		read.message = lastMessageFromTranscript(p);
+		if (read.message) read.summary = cleanSummary(read.message);
+	}
 	return read;
 }
 /** The last non-empty `assistant.message` of the turn that just ended in
@@ -9527,7 +9611,7 @@ function lastMessageFromTranscript(p) {
 				try {
 					const ev = JSON.parse(lines[i]);
 					const content = ev.type === "assistant.message" ? ev.data?.content : void 0;
-					if (typeof content === "string" && content.trim()) return cleanSummary(content);
+					if (typeof content === "string" && content.trim()) return content.trim();
 				} catch {}
 			}
 		} finally {
@@ -10215,7 +10299,8 @@ function readHook$1(p, reported) {
 	const summary = str$1(p.summary);
 	return {
 		reason: reported,
-		summary: summary ? cleanSummary(summary) : void 0
+		summary: summary ? cleanSummary(summary) : void 0,
+		message: summary || void 0
 	};
 }
 var opencode = {
@@ -10323,7 +10408,8 @@ function readHook(p, reported) {
 	const summary = str$1(p.summary);
 	return {
 		reason: reported,
-		summary: summary ? cleanSummary(summary) : void 0
+		summary: summary ? cleanSummary(summary) : void 0,
+		message: summary || void 0
 	};
 }
 //#endregion
@@ -10410,14 +10496,15 @@ function getSession(id) {
 * 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) {
+function createSession(workspaceId, agent, ifEmpty = false, parent) {
 	if (!isKnownAgent(agent)) throw new Error(`unknown session kind: ${agent}`);
 	if (ifEmpty) {
 		const first = listSessions(workspaceId)[0];
 		if (first) return first;
 	}
+	const parentId = parent && getSession(parent)?.workspace_id === workspaceId ? parent : null;
 	const id = Math.random().toString(36).slice(2, 10);
-	db.prepare("INSERT INTO sessions (id, workspace_id, agent) VALUES (?, ?, ?)").run(id, workspaceId, agent);
+	db.prepare("INSERT INTO sessions (id, workspace_id, agent, parent_id) VALUES (?, ?, ?, ?)").run(id, workspaceId, agent, parentId);
 	notifySessionsChanged(workspaceId);
 	return getSession(id);
 }
@@ -10438,7 +10525,14 @@ async function killSession(id) {
 async function disposeSessions(sessions) {
 	for (const session of sessions) await disposeSession(session.id);
 }
+/** Told of a session about to go, while its row is still there (its
+* messages go with it: server/messages answers what it owed first). */
+var disposeListeners = /* @__PURE__ */ new Set();
+function onSessionDispose(fn) {
+	disposeListeners.add(fn);
+}
 async function disposeSession(id) {
+	for (const fn of disposeListeners) fn(id);
 	await tmux([
 		"kill-session",
 		"-t",
@@ -10956,4 +11050,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { iconSvg as $, subscribe as $t, blankRow as A, which as At, onPhaseChange as B, agentById as Bt, tmuxWasStarted as C, doctor as Ct, inside as D, setupPath as Dt, reportsWorking as E, miseVersions as Et, interruptedSinceReport as F, untrackedCacheAllowed as Ft, settleQuietWorking as G, applyPrefChange as Gt, setAgentPhase as H, catalogPin as Ht, noteBackground as I, firewallProbe as It, agentFromCommand as J, checked as Jt, agentBadge as K, FRAME_ANCESTORS as Kt, noteInterrupt as L, DEFAULT_GITHUB_HOST as Lt, clearAgentPhase as M, unreachableText as Mt, hookPhase as N, enableUntrackedCache as Nt, realInside as O, stableGh as Ot, hookReportedAt as P, unsetCaches as Pt, getInstance as Q, publishJson as Qt, noteUserAnswered as R, PROJECT_TOOLS as Rt, tmuxName as S, discoverAgents as St, readHookPayload as T, miseInstalls as Tt, setScrapedPhase as U, parseAgentId as Ut, sessionWatched as V, agentLabel$1 as Vt, setSessionViewers as W, toolById as Wt, agentMeta as X, readBody as Xt, agentLabel as Y, httpError as Yt, ACCENT_RE as Z, publish as Zt, notifySessionsChanged as _, getSetting as _t, creationOf as a, TMUX_SOCKET as an, saveSubscription as at, sendToSession as b, setPref as bt, forgetPanes as c, gitEnv as cn, PREF_MAX as ct, killWorkspaceSessions as d, config as dn, allPrefs as dt, subscriberCount as en, manifest as et, listPanes as f, shared as fn, changePref as ft, newSessionArgs as g, enabledAgents as gt, markTmuxStarted as h, disabledAgents as ht, createSession as i, workspacePath as in, pushPublicKey as it, agentPhase as j, hostReach as jt, realInsideSync as k, tilde as kt, getSession as l, run$2 as ln, WORKSPACE_PREFS as lt, listSessions as m, withLock as mn, deleteWorkspacePrefs as mt, cleanEnv as n, db as nn, setInstance as nt, disposeSessions as o, gh as on, sendPush as ot, listPanesWithin as p, swr as pn, deleteSetting as pt, agentFamily as q, FRAME_HEADERS as qt, clearTmuxStarted as r, get as rn, deleteSubscription as rt, ensureTmuxServer as s, git as sn, validSubscription as st, beginCreation as t, all as tn, normalizeAccent as tt, killSession as u, tmux as un, agentChoices as ut, panePids as v, preferredAgent as vt, AGENTS as w, ghKnownHosts as wt, sessionStates as x, setSetting as xt, renameSession as y, setDisabledAgents as yt, notifyEventOn as z, TOOLS as zt };
+export { agentBadge as $, FRAME_ANCESTORS as $t, realInsideSync as A, doctor as At, noteTyped as B, enableUntrackedCache as Bt, tmuxName as C, enabledAgents as Ct, reportsWorking as D, setPref as Dt, readHookPayload as E, setDisabledAgents as Et, hookReportedAt as F, stableGh as Ft, sessionWatched as G, PROJECT_TOOLS as Gt, notifyEventOn as H, untrackedCacheAllowed as Ht, interruptedSinceReport as I, tilde as It, setScrapedPhase as J, agentLabel$1 as Jt, setAgentPhase as K, TOOLS as Kt, lastTypedAt as L, which as Lt, agentPhase as M, miseInstalls as Mt, clearAgentPhase as N, miseVersions as Nt, inside as O, setSetting as Ot, hookPhase as P, setupPath as Pt, turnSettling as Q, applyPrefChange as Qt, noteBackground as R, hostReach as Rt, sessionStates as S, disabledAgents as St, AGENTS as T, preferredAgent as Tt, onPhaseChange as U, firewallProbe as Ut, noteUserAnswered as V, unsetCaches as Vt, onTurnEnd as W, DEFAULT_GITHUB_HOST as Wt, settleQuietWorking as X, parseAgentId as Xt, setSessionViewers as Y, catalogPin as Yt, turnPhase as Z, toolById as Zt, notifySessionsChanged as _, tmux as _n, agentChoices as _t, creationOf as a, publishJson as an, getInstance as at, renameSession as b, swr as bn, deleteSetting as bt, forgetPanes as c, all as cn, normalizeAccent as ct, killWorkspaceSessions as d, workspacePath as dn, pushPublicKey as dt, FRAME_HEADERS as en, agentFamily as et, listPanes as f, TMUX_SOCKET as fn, saveSubscription as ft, newSessionArgs as g, run$2 as gn, WORKSPACE_PREFS as gt, markTmuxStarted as h, gitEnv as hn, PREF_MAX as ht, createSession as i, publish as in, ACCENT_RE as it, blankRow as j, ghKnownHosts as jt, realInside as k, discoverAgents as kt, getSession as l, db as ln, setInstance as lt, listSessions as m, git as mn, validSubscription as mt, cleanEnv as n, httpError as nn, agentLabel as nt, disposeSessions as o, subscribe as on, iconSvg as ot, listPanesWithin as p, gh as pn, sendPush as pt, setExpecting as q, agentById as qt, clearTmuxStarted as r, readBody as rn, agentMeta as rt, ensureTmuxServer as s, subscriberCount as sn, manifest as st, beginCreation as t, checked as tn, agentFromCommand as tt, killSession as u, get as un, deleteSubscription as ut, onSessionDispose as v, config as vn, allPrefs as vt, tmuxWasStarted as w, getSetting as wt, sendToSession as x, withLock as xn, deleteWorkspacePrefs as xt, panePids as y, shared as yn, changePref as yt, noteInterrupt as z, unreachableText as zt };

package/dist/_L2HNAA_8.js

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