@bondsmith/bondsmithd 0.1.7 → 0.1.9

package/README.md

@@ -81,6 +81,21 @@ The daemon reads it on its 5-second tick and shows it on the session. Anything e
 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 can also share the plan it is working against, which Bondsmith shows above the session's
+changes. Run this from inside the session's pane once the plan is agreed, and again whenever it changes:
+
+```sh
+tmux set-option -t "$TMUX_PANE" -q @bondsmith-plan "$(cat <<'EOF'
+# What the session is doing
+- step one
+- step two
+EOF
+)"
+```
+
+The value is markdown, cut at 32,768 characters. The daemon reads it only when the browser asks, so
+unlike the state report it has no timestamp and is not dropped when the pane writes output.
+
 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

package/dist/index.js

@@ -4,7 +4,7 @@
 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
@@ -16,7 +16,7 @@ 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 = 8;
 
 // ../../packages/local-agent-protocol/src/project-path.ts
 var PROJECT_PATH_INVALID_REASONS = [
@@ -60,6 +60,9 @@ 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_PLAN_CHARS = 32 * 1024;
 var MAX_TERMINAL_DIMENSION = 1e3;
 var terminalSizeSchema = z2.object({
   cols: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
@@ -95,14 +98,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) })
@@ -166,6 +187,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(),
@@ -173,6 +203,11 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
     staged: z2.boolean(),
     requestId: z2.string().min(1).max(200)
   }),
+  z2.object({
+    type: z2.literal("workspace.getPlan"),
+    sessionId: z2.string(),
+    requestId: z2.string().min(1).max(200)
+  }),
   z2.object({
     type: z2.literal("project.validatePath"),
     path: z2.string().min(1).max(4096),
@@ -250,12 +285,24 @@ 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(),
     requestId: z2.string(),
     diff: workspaceFileDiffSchema
   }),
+  z2.object({
+    type: z2.literal("workspace.plan"),
+    sessionId: z2.string(),
+    requestId: z2.string(),
+    plan: z2.string().max(MAX_PLAN_CHARS).nullable()
+  }),
   z2.object({
     type: z2.literal("project.pathValidated"),
     requestId: z2.string(),
@@ -370,6 +417,8 @@ var SIGNABLE_ACTIONS = [
   "session.list",
   "workspace.getStatus",
   "workspace.getDiff",
+  "workspace.readFileRange",
+  "workspace.getPlan",
   "project.validatePath"
 ];
 var envelopeSchema = z3.object({
@@ -855,6 +904,9 @@ import { promisify } from "util";
 var execFile = promisify(execFileCb);
 var MAX_GIT_OUTPUT_BYTES = 64 * 1024 * 1024;
 var SAFE_DIFF_FLAGS = ["--no-ext-diff", "--no-textconv"];
+function splitNulList(output) {
+  return output.split("\0").filter((entry) => entry.length > 0);
+}
 var GitNotARepoError = class extends Error {
   constructor() {
     super("not a git repository");
@@ -954,7 +1006,7 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.7" : "dev";
+var DAEMON_VERSION = true ? "0.1.9" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1025,6 +1077,16 @@ async function getSessionActivity(tmuxSessionName) {
     return null;
   }
 }
+var PLAN_OPTION = "@bondsmith-plan";
+async function getSessionPlan(tmuxSessionName) {
+  try {
+    const plan = (await runTmux(["show-options", "-qv", "-t", tmuxSessionName, PLAN_OPTION])).trim();
+    return plan ? plan.slice(0, MAX_PLAN_CHARS) : null;
+  } catch (error2) {
+    if (error2 instanceof TmuxNotFoundError) throw error2;
+    return null;
+  }
+}
 async function listTmuxSessions(formatString) {
   try {
     return await runTmux(["list-sessions", "-F", formatString]);
@@ -1378,12 +1440,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));
@@ -1395,7 +1487,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 () => {
@@ -1421,7 +1513,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") {
@@ -1449,6 +1541,7 @@ async function dispatch(conn, message, {
   broadcast,
   getWorkspaceStatus: getWorkspaceStatus2,
   getWorkspaceDiff: getWorkspaceDiff2,
+  readFileRange: readFileRange2,
   validateProjectPath: validateProjectPath2,
   hostname: hostname3,
   daemonFingerprint,
@@ -1584,12 +1677,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));
       }
@@ -1605,14 +1700,54 @@ 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;
+    }
+    case "workspace.getPlan": {
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
+      if (!session) return;
+      try {
+        const plan = await getSessionPlan(session.tmuxSessionName);
+        conn.send({
+          type: "workspace.plan",
+          sessionId: message.sessionId,
+          requestId: message.requestId,
+          plan
+        });
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to read the session plan"), message.requestId));
       }
       return;
     }
@@ -2552,9 +2687,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";
@@ -2595,7 +2820,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;
@@ -2613,7 +2838,7 @@ async function listChangedPaths(cwd, baseSha) {
     runGitDiff(["--relative", "--name-only", "-z", baseSha], cwd),
     runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd)
   ]);
-  const paths = [...tracked.split("\0"), ...untracked.split("\0")].filter((p) => p.length > 0);
+  const paths = [...splitNulList(tracked), ...splitNulList(untracked)];
   return [...new Set(paths)];
 }
 async function captureBaseline(cwd, options) {
@@ -2725,7 +2950,7 @@ async function isGitRepo(cwd) {
 }
 function parseNumstat(output) {
   const map = /* @__PURE__ */ new Map();
-  const fields = output.split("\0").filter((f) => f.length > 0);
+  const fields = splitNulList(output);
   let i = 0;
   while (i < fields.length) {
     const line = fields[i];
@@ -2766,7 +2991,7 @@ function isStatusLetter(letter) {
   return letter in STATUS_BY_LETTER;
 }
 function parseNameStatus(output) {
-  const fields = output.split("\0").filter((f) => f.length > 0);
+  const fields = splitNulList(output);
   const changed = [];
   let i = 0;
   while (i < fields.length) {
@@ -2785,16 +3010,57 @@ function parseNameStatus(output) {
   }
   return changed;
 }
+var reportedFailures = /* @__PURE__ */ new Map();
+async function loadDefaultBranchView(cwd, baseSha) {
+  const defaultRef = await findDefaultBranchRef(cwd);
+  if (!defaultRef) {
+    reportedFailures.delete(cwd);
+    return null;
+  }
+  try {
+    const defaultSha = (await runGit(["rev-parse", "--verify", "--quiet", `${defaultRef}^{commit}`], cwd)).trim();
+    const forkSha = (await runGit(["merge-base", baseSha, defaultSha], cwd)).trim();
+    const [differing, deletedSinceFork] = await Promise.all([
+      runGitDiff(["--relative", "--name-only", "-z", defaultSha], cwd),
+      runGitDiff(["--relative", "--name-only", "--diff-filter=D", "-z", forkSha, defaultSha], cwd)
+    ]);
+    reportedFailures.delete(cwd);
+    return {
+      differing: new Set(splitNulList(differing)),
+      deletedSinceFork: new Set(splitNulList(deletedSinceFork))
+    };
+  } catch (error2) {
+    const signature = `${defaultRef}: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    if (reportedFailures.get(cwd) !== signature) {
+      reportedFailures.set(cwd, signature);
+      console.error("Failed to compare with the default branch; listing files unfiltered", {
+        cwd,
+        defaultRef,
+        error: error2
+      });
+    }
+    return null;
+  }
+}
+function dropAlreadyOnDefaultBranch(files, view) {
+  if (!view) return files;
+  return files.filter((file) => {
+    if (file.status === "untracked") return true;
+    if (file.status === "deleted") return !view.deletedSinceFork.has(file.path);
+    return view.differing.has(file.path) || file.previousPath !== void 0 && view.differing.has(file.previousPath);
+  });
+}
 async function getWorkspaceStatus(cwd, baseline) {
   const branch = await getCurrentBranch(cwd);
   if (branch === null && !await isGitRepo(cwd)) {
     return { isGitRepo: false, branch: null, files: [] };
   }
   const base = await resolveBaseFor(cwd, baseline);
-  const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+  const [nameStatusRaw, numstatRaw, untrackedRaw, defaultBranchView] = await Promise.all([
     runGitDiff(["--relative", "--name-status", "-z", "-M", base.sha], cwd),
     runGitDiff(["--relative", "--numstat", "-z", "-M", base.sha], cwd),
-    runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd)
+    runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd),
+    loadDefaultBranchView(cwd, base.sha)
   ]);
   const numstat = parseNumstat(numstatRaw);
   const tracked = parseNameStatus(nameStatusRaw).map((changed) => {
@@ -2809,7 +3075,7 @@ async function getWorkspaceStatus(cwd, baseline) {
       binary: counts?.binary ?? false
     };
   });
-  const untracked = untrackedRaw.split("\0").filter((path) => path.length > 0).map((path) => ({
+  const untracked = splitNulList(untrackedRaw).map((path) => ({
     path,
     status: "untracked",
     staged: false,
@@ -2817,7 +3083,7 @@ async function getWorkspaceStatus(cwd, baseline) {
     deletions: null,
     binary: false
   }));
-  const files = [...tracked, ...untracked];
+  const files = dropAlreadyOnDefaultBranch([...tracked, ...untracked], defaultBranchView);
   return {
     isGitRepo: true,
     branch,
@@ -2852,8 +3118,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],
@@ -2863,13 +3133,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
@@ -3092,7 +3376,7 @@ function resolveSessionAttention(report, 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}`);
@@ -3100,7 +3384,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);
@@ -3484,6 +3768,7 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         broadcast,
         getWorkspaceStatus,
         getWorkspaceDiff,
+        readFileRange,
         validateProjectPath,
         hostname: () => hostname(),
         daemonFingerprint,
@@ -3524,10 +3809,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();
@@ -3581,6 +3866,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.7",
+	"version": "0.1.9",
 	"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",