@bondsmith/bondsmithd 0.1.6 → 0.1.7

package/README.md

@@ -66,6 +66,30 @@ daemon". Reload the page first; if that doesn't fix it, update the daemon as abo
 - Keeps tmux itself as the only source of truth — no database. Restarting the daemon rediscovers
   running sessions from tmux.
 
+## Agent state
+
+An agent can tell Bondsmith what it is doing by running this from inside its session's pane, usually
+from one of its hooks. `$TMUX_PANE` is set by tmux in every pane, so the command targets the session
+that pane belongs to:
+
+```sh
+tmux set-option -t "$TMUX_PANE" -q @bondsmith-agent-state "waiting:$(date +%s)"
+```
+
+The value is `<state>:<epoch seconds>`, where state is `working`, `waiting` (needs the user) or `done`.
+The daemon reads it on its 5-second tick and shows it on the session. Anything else is ignored, as is
+a report dated in the future. A `waiting` or `done` report is dropped once the pane writes output more
+than 2 seconds after it, since that means the agent moved on; a `working` report is not.
+
+An agent with no hook can still get attention by ringing the terminal bell (`printf '\a'`). A bell
+rung in a session nobody has looked at marks it as waiting, whatever its last report said, until tmux
+clears the flag when someone attaches to the session. Agents that can ring the bell for approvals or
+a finished turn work this way with nothing to install.
+
+tmux only flags a bell when no client is attached to the session or the bell is in a window other than
+the one the attached client has open. A session whose terminal is open in a browser tab, even a hidden
+one, counts as being looked at, so a bell in it is not flagged; use the hook report for that case.
+
 ## Production connectivity (current status)
 
 `bondsmithd` connects outbound to the Bondsmith relay by default (`BONDSMITH_RELAY_ENABLED=true`,

package/dist/index.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "url";
 
 // ../../packages/local-agent-protocol/src/session.ts
 var SESSION_STATUSES = ["running", "exited"];
+var AGENT_STATES = ["working", "waiting", "done"];
 
 // ../../packages/local-agent-protocol/src/messages.ts
 var REPLAYED_COMMAND_MESSAGE = "command already used (replay rejected)";
@@ -76,7 +77,9 @@ var localSessionSchema = z2.object({
   repositoryFullName: z2.string().nullable(),
   lastActivityAt: z2.string().nullable(),
   changedFileCount: z2.number().int().nonnegative().nullable(),
-  worktreeOf: z2.string().nullable()
+  worktreeOf: z2.string().nullable(),
+  // .catch(undefined): a state this version doesn't know must never drop the whole session message.
+  agentState: z2.enum(AGENT_STATES).nullable().optional().catch(void 0)
 });
 var workspaceFileEntrySchema = z2.object({
   path: z2.string(),
@@ -951,7 +954,7 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.6" : "dev";
+var DAEMON_VERSION = true ? "0.1.7" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1012,9 +1015,9 @@ async function sendKeysLiteral(tmuxSessionName, text) {
 async function capturePane(tmuxSessionName) {
   return runTmux(["capture-pane", "-t", tmuxSessionName, "-p", "-e"]);
 }
-async function getPaneActivity(tmuxSessionName) {
+async function getSessionActivity(tmuxSessionName) {
   try {
-    const out = (await runTmux(["display-message", "-p", "-t", tmuxSessionName, "#{pane_activity}"])).trim();
+    const out = (await runTmux(["display-message", "-p", "-t", tmuxSessionName, "#{window_activity}"])).trim();
     const seconds = Number(out);
     if (!out || Number.isNaN(seconds)) return null;
     return new Date(seconds * 1e3).toISOString();
@@ -2827,7 +2830,7 @@ async function enrichSessionWithGitMetadata(session, baseline) {
     getCurrentBranch(session.cwd),
     getRepositoryFullName(session.cwd),
     getWorkspaceStatus(session.cwd, baseline),
-    getPaneActivity(session.tmuxSessionName)
+    getSessionActivity(session.tmuxSessionName)
   ]);
   const changedFileCount = status.isGitRepo ? new Set(status.files.map((f) => f.path)).size : null;
   return {
@@ -3054,6 +3057,38 @@ async function removeWorktree(sourceCwd, worktreePath) {
   }
 }
 
+// src/sessions/tmux/agent-state.ts
+var LIVE_SESSION_REPORTS_FORMAT = "#{session_name}	#{@bondsmith-agent-state}	#{window_bell_flag}";
+var AGENT_STATE_OUTPUT_GRACE_MS = 2e3;
+var FUTURE_REPORT_ALLOWANCE_MS = 2e3;
+var SETTLED_STATES = /* @__PURE__ */ new Set(["waiting", "done"]);
+function isAgentState(value) {
+  return AGENT_STATES.includes(value);
+}
+function parseLiveSessionReports(output) {
+  const reports = /* @__PURE__ */ new Map();
+  for (const line of output.split("\n")) {
+    const [sessionName, agentState = "", bell = ""] = line.split("	");
+    if (sessionName) reports.set(sessionName, { agentState, bell: bell === "1" });
+  }
+  return reports;
+}
+function resolveAgentState(raw, lastActivityAt, nowMs = Date.now()) {
+  if (!raw) return null;
+  const [state, epoch] = raw.split(":");
+  if (!state || !isAgentState(state) || !epoch || !/^\d+$/.test(epoch)) return null;
+  const reportedAtMs = Number(epoch) * 1e3;
+  if (reportedAtMs > nowMs + FUTURE_REPORT_ALLOWANCE_MS) return null;
+  if (SETTLED_STATES.has(state) && lastActivityAt) {
+    if (Date.parse(lastActivityAt) > reportedAtMs + AGENT_STATE_OUTPUT_GRACE_MS) return null;
+  }
+  return state;
+}
+function resolveSessionAttention(report, lastActivityAt, nowMs) {
+  if (report?.bell) return "waiting";
+  return resolveAgentState(report?.agentState, lastActivityAt, nowMs);
+}
+
 // src/sessions/tmux/create.ts
 import { access } from "fs/promises";
 import { homedir as homedir5 } from "os";
@@ -3277,13 +3312,12 @@ var SessionManager = class {
    * at create/discover — otherwise the associated-work lookup (open PR whose
    * head = session.branch) stays pinned to a branch the developer already
    * left. `session.updated` is only emitted when something actually changed,
-   * so an idle session doesn't broadcast every tick.
+   * so an idle session doesn't broadcast every tick. The same tick re-reads each session's agent report.
    */
   async reconcile() {
-    let liveSessionNames = /* @__PURE__ */ new Set();
+    let agentReports = /* @__PURE__ */ new Map();
     try {
-      const output = await listTmuxSessions("#{session_name}");
-      liveSessionNames = new Set(output.split("\n").filter((name) => name.length > 0));
+      agentReports = parseLiveSessionReports(await listTmuxSessions(LIVE_SESSION_REPORTS_FORMAT));
     } catch (error2) {
       if (error2 instanceof TmuxNotFoundError) console.error(`
 ${error2.message}
@@ -3297,16 +3331,23 @@ ${error2.message}
     }
     await Promise.all(
       Array.from(this.sessions.values()).map(async (session) => {
-        if (!liveSessionNames.has(session.tmuxSessionName)) {
+        if (!agentReports.has(session.tmuxSessionName)) {
           this.removeAsExited(session);
           return;
         }
         try {
-          const updated = await enrichSessionWithGitMetadata(
+          const enriched = await enrichSessionWithGitMetadata(
             session,
             this.baselines.get(session.id)
           );
-          if (!gitSnapshotEquals(session, updated)) {
+          const updated = {
+            ...enriched,
+            agentState: resolveSessionAttention(
+              agentReports.get(session.tmuxSessionName),
+              enriched.lastActivityAt
+            )
+          };
+          if (!snapshotEquals(session, updated)) {
             this.sessions.set(session.id, updated);
             this.emitUpdated(updated);
           }
@@ -3327,8 +3368,8 @@ ${error2.message}
     return updated;
   }
 };
-function gitSnapshotEquals(a, b) {
-  return a.branch === b.branch && a.repositoryFullName === b.repositoryFullName && a.changedFileCount === b.changedFileCount && a.lastActivityAt === b.lastActivityAt;
+function snapshotEquals(a, b) {
+  return a.branch === b.branch && a.repositoryFullName === b.repositoryFullName && a.changedFileCount === b.changedFileCount && a.lastActivityAt === b.lastActivityAt && (a.agentState ?? null) === (b.agentState ?? null);
 }
 
 // src/ws/server.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"private": false,
 	"description": "Local daemon for Bondsmith agent sessions — runs on the user's own machine, pairs with a Bondsmith account, and exposes tmux-backed terminal sessions to the Bondsmith web app over a signed WebSocket protocol.",
 	"homepage": "https://bondsmith.dev",