@bondsmith/bondsmithd 0.1.6 → 0.1.8

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

@@ -4,18 +4,19 @@
 import { createServer } from "http";
 import { existsSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname4, join as join8 } from "path";
 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)";
 var INVALID_MESSAGE_ERROR = "invalid message";
 
 // ../../packages/local-agent-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 4;
+var PROTOCOL_VERSION = 7;
 
 // ../../packages/local-agent-protocol/src/project-path.ts
 var PROJECT_PATH_INVALID_REASONS = [
@@ -59,6 +60,8 @@ var signedConnectionChallengeSchema = z.object({
 var MAX_INSERT_TEXT_BYTES = 32 * 1024;
 var MAX_INPUT_CHARS = 16 * 1024;
 var MAX_WIRE_MESSAGE_BYTES = 256 * 1024;
+var MAX_DAEMON_REPLY_BYTES = 200 * 1024;
+var MAX_RANGE_LINES = 500;
 var MAX_TERMINAL_DIMENSION = 1e3;
 var terminalSizeSchema = z2.object({
   cols: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
@@ -76,7 +79,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(),
@@ -92,14 +97,32 @@ var workspaceStatusSchema = z2.object({
   branch: z2.string().nullable(),
   // .catch(undefined): a malformed informational field must never drop the whole status message.
   baseRef: z2.string().nullable().optional().catch(void 0),
-  files: z2.array(workspaceFileEntrySchema)
+  files: z2.array(workspaceFileEntrySchema),
+  totalFiles: z2.number().int().nonnegative().optional().catch(void 0)
 });
 var workspaceFileDiffSchema = z2.object({
   path: z2.string(),
   staged: z2.boolean(),
   patch: z2.string().nullable(),
-  binary: z2.boolean()
+  binary: z2.boolean(),
+  tooLarge: z2.boolean().optional(),
+  version: z2.string().optional()
 });
+var workspaceFileRangeSchema = z2.discriminatedUnion("ok", [
+  z2.object({
+    ok: z2.literal(true),
+    path: z2.string(),
+    startLine: z2.number().int().min(1),
+    lines: z2.array(z2.string()).max(MAX_RANGE_LINES),
+    totalLines: z2.number().int().nonnegative(),
+    version: z2.string()
+  }),
+  z2.object({
+    ok: z2.literal(false),
+    path: z2.string(),
+    reason: z2.enum(["changed", "missing", "binary", "too_large", "not_allowed"])
+  })
+]);
 var projectPathValidationSchema = z2.discriminatedUnion("valid", [
   z2.object({ valid: z2.literal(true), path: z2.string() }),
   z2.object({ valid: z2.literal(false), reason: z2.enum(PROJECT_PATH_INVALID_REASONS) })
@@ -163,6 +186,15 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
     sessionId: z2.string(),
     requestId: z2.string().min(1).max(200)
   }),
+  z2.object({
+    type: z2.literal("workspace.readFileRange"),
+    sessionId: z2.string(),
+    path: z2.string().min(1).max(4096),
+    startLine: z2.number().int().min(1),
+    lineCount: z2.number().int().min(1).max(MAX_RANGE_LINES),
+    version: z2.string().min(1).max(100),
+    requestId: z2.string().min(1).max(200)
+  }),
   z2.object({
     type: z2.literal("workspace.getDiff"),
     sessionId: z2.string(),
@@ -247,6 +279,12 @@ var daemonMessageSchema = z2.discriminatedUnion("type", [
     requestId: z2.string(),
     status: workspaceStatusSchema
   }),
+  z2.object({
+    type: z2.literal("workspace.fileRange"),
+    sessionId: z2.string(),
+    requestId: z2.string(),
+    range: workspaceFileRangeSchema
+  }),
   z2.object({
     type: z2.literal("workspace.diff"),
     sessionId: z2.string(),
@@ -367,6 +405,7 @@ var SIGNABLE_ACTIONS = [
   "session.list",
   "workspace.getStatus",
   "workspace.getDiff",
+  "workspace.readFileRange",
   "project.validatePath"
 ];
 var envelopeSchema = z3.object({
@@ -951,7 +990,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.8" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1012,9 +1051,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();
@@ -1375,12 +1414,42 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
 function error(message, requestId) {
   return { type: "error", message, requestId };
 }
+function fitDiffReply(reply) {
+  const { patch, tooLarge } = reply.diff;
+  const fits = (patch === null || patch.length <= MAX_DAEMON_REPLY_BYTES) && Buffer.byteLength(JSON.stringify(reply)) <= MAX_DAEMON_REPLY_BYTES;
+  if (tooLarge || fits) return reply;
+  return { ...reply, diff: { ...reply.diff, patch: null, tooLarge: true } };
+}
+function fitStatusReply(reply) {
+  if (Buffer.byteLength(JSON.stringify(reply)) <= MAX_DAEMON_REPLY_BYTES) return reply;
+  const { files } = reply.status;
+  const bare = { ...reply, status: { ...reply.status, files: [], totalFiles: files.length } };
+  let budget = MAX_DAEMON_REPLY_BYTES - Buffer.byteLength(JSON.stringify(bare));
+  const kept = [];
+  for (const file of files) {
+    const cost = Buffer.byteLength(JSON.stringify(file)) + 1;
+    if (cost > budget) break;
+    budget -= cost;
+    kept.push(file);
+  }
+  return { ...bare, status: { ...bare.status, files: kept } };
+}
 function errorMessageOf(err, fallback) {
   return err instanceof Error ? err.message : fallback;
 }
 function requestIdOf(message) {
   return "requestId" in message ? message.requestId : void 0;
 }
+function stringRequestId(value) {
+  if (typeof value !== "object" || value === null || !("requestId" in value)) return void 0;
+  const { requestId } = value;
+  return typeof requestId === "string" && requestId !== "" ? requestId.slice(0, 200) : void 0;
+}
+function requestIdOfUnparsed(raw) {
+  const envelope = typeof raw === "object" && raw !== null && "envelope" in raw ? raw.envelope : void 0;
+  const payload = typeof envelope === "object" && envelope !== null && "payload" in envelope ? envelope.payload : void 0;
+  return stringRequestId(payload) ?? stringRequestId(raw);
+}
 function getSessionOrError(sessionManager, conn, sessionId, requestId) {
   const session = sessionManager.get(sessionId);
   if (!session) conn.send(error("unknown session", requestId));
@@ -1392,7 +1461,7 @@ async function handleBrowserMessage(conn, raw, deps) {
     const { envelope } = signedCommand.data;
     const innerMessage = browserMessageSchema.safeParse(envelope.payload);
     if (!innerMessage.success || innerMessage.data.type !== envelope.action) {
-      conn.send(error(INVALID_MESSAGE_ERROR));
+      conn.send(error(INVALID_MESSAGE_ERROR, requestIdOfUnparsed(raw)));
       return;
     }
     const admitted = await conn.admitInOrder(async () => {
@@ -1418,7 +1487,7 @@ async function handleBrowserMessage(conn, raw, deps) {
   }
   const parsed = browserMessageSchema.safeParse(raw);
   if (!parsed.success) {
-    conn.send(error(INVALID_MESSAGE_ERROR));
+    conn.send(error(INVALID_MESSAGE_ERROR, requestIdOfUnparsed(raw)));
     return;
   }
   if (parsed.data.type === "connection.authenticate") {
@@ -1446,6 +1515,7 @@ async function dispatch(conn, message, {
   broadcast,
   getWorkspaceStatus: getWorkspaceStatus2,
   getWorkspaceDiff: getWorkspaceDiff2,
+  readFileRange: readFileRange2,
   validateProjectPath: validateProjectPath2,
   hostname: hostname3,
   daemonFingerprint,
@@ -1581,12 +1651,14 @@ async function dispatch(conn, message, {
           session.cwd,
           sessionManager.getBaseline(session.id)
         );
-        conn.send({
-          type: "workspace.status",
-          sessionId: message.sessionId,
-          requestId: message.requestId,
-          status
-        });
+        conn.send(
+          fitStatusReply({
+            type: "workspace.status",
+            sessionId: message.sessionId,
+            requestId: message.requestId,
+            status
+          })
+        );
       } catch (err) {
         conn.send(error(errorMessageOf(err, "failed to read workspace status"), message.requestId));
       }
@@ -1602,14 +1674,38 @@ async function dispatch(conn, message, {
           message.staged,
           sessionManager.getBaseline(session.id)
         );
+        conn.send(
+          fitDiffReply({
+            type: "workspace.diff",
+            sessionId: message.sessionId,
+            requestId: message.requestId,
+            diff
+          })
+        );
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to read workspace diff"), message.requestId));
+      }
+      return;
+    }
+    case "workspace.readFileRange": {
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
+      if (!session) return;
+      try {
+        const range = await readFileRange2(
+          session.cwd,
+          message.path,
+          message.startLine,
+          message.lineCount,
+          message.version
+        );
         conn.send({
-          type: "workspace.diff",
+          type: "workspace.fileRange",
           sessionId: message.sessionId,
           requestId: message.requestId,
-          diff
+          range
         });
       } catch (err) {
-        conn.send(error(errorMessageOf(err, "failed to read workspace diff"), message.requestId));
+        conn.send(error(errorMessageOf(err, "failed to read file range"), message.requestId));
       }
       return;
     }
@@ -2549,9 +2645,99 @@ function presentPendingAuthorizationOnTerminal(store) {
   };
 }
 
+// src/sessions/files/read-range.ts
+import { constants } from "fs";
+import { lstat, open, realpath, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, sep } from "path";
+var MAX_RANGE_FILE_BYTES = 2 * 1024 * 1024;
+var REPLY_ENVELOPE_BYTES = 8 * 1024;
+var BINARY_SNIFF_BYTES = 8e3;
+function fileVersion(stats) {
+  return `${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.ino}`;
+}
+async function locateInside(cwd, path) {
+  if (isAbsolute2(path)) return { refused: "not_allowed" };
+  try {
+    const root = await realpath(cwd);
+    const lexical = join5(root, path);
+    if ((await lstat(lexical)).isSymbolicLink()) return { refused: "not_allowed" };
+    const real = await realpath(lexical);
+    return real === root || real.startsWith(root + sep) ? { found: real } : { refused: "missing" };
+  } catch {
+    return { refused: "missing" };
+  }
+}
+async function readExactly(handle, size) {
+  const buffer = Buffer.allocUnsafe(size + 1);
+  let filled = 0;
+  while (filled < buffer.length) {
+    const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
+    if (bytesRead === 0) break;
+    filled += bytesRead;
+  }
+  return filled === size ? buffer.subarray(0, size) : void 0;
+}
+async function currentFileVersion(cwd, path) {
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return void 0;
+  try {
+    return fileVersion(await stat2(located.found));
+  } catch {
+    return void 0;
+  }
+}
+function splitLines(text) {
+  if (text === "") return [];
+  const lines = text.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+async function readFileRange(cwd, path, startLine, lineCount, version) {
+  const refuse = (reason) => ({ ok: false, path, reason });
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return refuse(located.refused);
+  let content;
+  let handle;
+  try {
+    handle = await open(
+      located.found,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+    const before = await handle.stat();
+    if (!before.isFile()) return refuse("not_allowed");
+    if (fileVersion(before) !== version) return refuse("changed");
+    if (before.size > MAX_RANGE_FILE_BYTES) return refuse("too_large");
+    const bytes = await readExactly(handle, before.size);
+    if (bytes === void 0 || fileVersion(await handle.stat()) !== version) {
+      return refuse("changed");
+    }
+    content = bytes;
+  } catch {
+    return refuse("missing");
+  } finally {
+    await handle?.close();
+  }
+  if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return refuse("binary");
+  const lines = splitLines(content.toString("utf8"));
+  const page = [];
+  let budget = MAX_DAEMON_REPLY_BYTES - REPLY_ENVELOPE_BYTES;
+  const wanted = Math.min(lineCount, MAX_RANGE_LINES);
+  for (let index = startLine - 1; index < lines.length && page.length < wanted; index++) {
+    const line = lines[index];
+    const cost = Buffer.byteLength(JSON.stringify(line)) + 1;
+    if (cost > budget) {
+      if (page.length === 0) return refuse("too_large");
+      break;
+    }
+    budget -= cost;
+    page.push(line);
+  }
+  return { ok: true, path, startLine, lines: page, totalLines: lines.length, version };
+}
+
 // src/sessions/git/baseline.ts
-import { lstat } from "fs/promises";
-import { join as join5 } from "path";
+import { lstat as lstat2 } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/sessions/git/base.ts
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
@@ -2592,7 +2778,7 @@ var MAX_PREEXISTING_FILES = 200;
 var DELETED = "deleted";
 async function fingerprintFile(cwd, path) {
   try {
-    const stats = await lstat(join5(cwd, path));
+    const stats = await lstat2(join6(cwd, path));
     return `${stats.size}:${Math.trunc(stats.mtimeMs)}`;
   } catch {
     return DELETED;
@@ -2827,7 +3013,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 {
@@ -2849,8 +3035,12 @@ async function isUntracked(cwd, path) {
   const out = await runGit(["ls-files", "--others", "--exclude-standard", "--", path], cwd);
   return out.trim() !== "";
 }
+function isOutputOverflow(err) {
+  return err?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+}
 async function getWorkspaceDiff(cwd, path, staged, baseline) {
   const base = await resolveBaseFor(cwd, baseline);
+  const version = await currentFileVersion(cwd, path);
   const pathspec = await withRenameSource(cwd, base.sha, path);
   const numstat = await runGitDiff(
     ["--relative", "--numstat", "-M", base.sha, "--", ...pathspec],
@@ -2860,13 +3050,27 @@ async function getWorkspaceDiff(cwd, path, staged, baseline) {
   if (binary) {
     return { path, staged, patch: null, binary: true };
   }
-  let patch = await runGitDiff(["--relative", "-M", base.sha, "--", ...pathspec], cwd);
-  if (patch.trim() === "" && await isUntracked(cwd, path)) {
-    patch = await runGitDiffAllowingExitCodes(["--no-index", "--", "/dev/null", path], cwd, [
-      1
-    ]).catch(() => "");
+  try {
+    let patch = await runGitDiff(["--relative", "-M", base.sha, "--", ...pathspec], cwd);
+    if (patch.trim() === "" && await isUntracked(cwd, path)) {
+      patch = await runGitDiffAllowingExitCodes(["--no-index", "--", "/dev/null", path], cwd, [
+        1
+      ]).catch((err) => {
+        if (isOutputOverflow(err)) throw err;
+        return "";
+      });
+    }
+    return {
+      path,
+      staged,
+      patch: patch || null,
+      binary: false,
+      ...version === void 0 ? {} : { version }
+    };
+  } catch (err) {
+    if (isOutputOverflow(err)) return { path, staged, patch: null, binary: false, tooLarge: true };
+    throw err;
   }
-  return { path, staged, patch: patch || null, binary: false };
 }
 
 // src/ws/server.ts
@@ -3054,10 +3258,42 @@ 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";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var InvalidCwdError = class extends Error {
   constructor(cwd) {
     super(`working directory does not exist: ${cwd}`);
@@ -3065,7 +3301,7 @@ var InvalidCwdError = class extends Error {
   }
 };
 function worktreePathFor(sessionId) {
-  return join6(homedir5(), ".bondsmith", "worktrees", sessionId);
+  return join7(homedir5(), ".bondsmith", "worktrees", sessionId);
 }
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
@@ -3277,13 +3513,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 +3532,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 +3569,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
@@ -3443,6 +3685,7 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         broadcast,
         getWorkspaceStatus,
         getWorkspaceDiff,
+        readFileRange,
         validateProjectPath,
         hostname: () => hostname(),
         daemonFingerprint,
@@ -3483,10 +3726,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join7(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join7(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join7(repoRoot, ".env.local");
-  const envDefault = join7(repoRoot, ".env");
+  const repoRoot = join8(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
+  if (!existsSync(join8(repoRoot, "pnpm-workspace.yaml"))) return;
+  const envLocal = join8(repoRoot, ".env.local");
+  const envDefault = join8(repoRoot, ".env");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();
@@ -3540,6 +3783,7 @@ async function start() {
     ptyAttachments,
     getWorkspaceStatus,
     getWorkspaceDiff,
+    readFileRange,
     validateProjectPath,
     hostname: hostname2,
     pendingAuthorizations,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.6",
+	"version": "0.1.8",
 	"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",