@bondsmith/bondsmithd 0.1.5 → 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

@@ -4,11 +4,12 @@
 import { createServer } from "http";
 import { existsSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
+import { dirname as dirname4, join as join7 } 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)";
@@ -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.5" : "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();
@@ -1577,7 +1580,10 @@ async function dispatch(conn, message, {
       const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
       if (!session) return;
       try {
-        const status = await getWorkspaceStatus2(session.cwd);
+        const status = await getWorkspaceStatus2(
+          session.cwd,
+          sessionManager.getBaseline(session.id)
+        );
         conn.send({
           type: "workspace.status",
           sessionId: message.sessionId,
@@ -1593,7 +1599,12 @@ async function dispatch(conn, message, {
       const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
       if (!session) return;
       try {
-        const diff = await getWorkspaceDiff2(session.cwd, message.path, message.staged);
+        const diff = await getWorkspaceDiff2(
+          session.cwd,
+          message.path,
+          message.staged,
+          sessionManager.getBaseline(session.id)
+        );
         conn.send({
           type: "workspace.diff",
           sessionId: message.sessionId,
@@ -2541,6 +2552,10 @@ function presentPendingAuthorizationOnTerminal(store) {
   };
 }
 
+// src/sessions/git/baseline.ts
+import { lstat } from "fs/promises";
+import { join as join5 } from "path";
+
 // src/sessions/git/base.ts
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var DEFAULT_BRANCH_CANDIDATES = ["origin/main", "origin/master", "main", "master"];
@@ -2574,6 +2589,107 @@ async function resolveComparisonBase(cwd) {
   return mergeBase ? { sha: mergeBase, ref: defaultRef } : { sha: "HEAD", ref: null };
 }
 
+// src/sessions/git/baseline.ts
+var SESSION_START_REF = "session start";
+var MAX_PREEXISTING_FILES = 200;
+var DELETED = "deleted";
+async function fingerprintFile(cwd, path) {
+  try {
+    const stats = await lstat(join5(cwd, path));
+    return `${stats.size}:${Math.trunc(stats.mtimeMs)}`;
+  } catch {
+    return DELETED;
+  }
+}
+async function headSha(cwd) {
+  try {
+    return (await runGit(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd)).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function listChangedPaths(cwd, baseSha) {
+  const [tracked, untracked] = await Promise.all([
+    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);
+  return [...new Set(paths)];
+}
+async function captureBaseline(cwd, options) {
+  try {
+    await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  } catch {
+    return null;
+  }
+  try {
+    const baseSha = await headSha(cwd);
+    const preexisting = /* @__PURE__ */ new Map();
+    if (!options.freshCheckout) {
+      const changed = await listChangedPaths(cwd, baseSha ?? EMPTY_TREE_SHA);
+      for (const path of changed.slice(0, MAX_PREEXISTING_FILES)) {
+        preexisting.set(path, await fingerprintFile(cwd, path));
+      }
+    }
+    return { baseSha, preexisting };
+  } catch (error2) {
+    console.error("Failed to take a session baseline; comparing against the default branch", {
+      cwd,
+      error: error2
+    });
+    return null;
+  }
+}
+async function commitExists(cwd, sha) {
+  try {
+    await runGit(["rev-parse", "--verify", "--quiet", `${sha}^{commit}`], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBaseFor(cwd, baseline) {
+  if (!baseline) return resolveComparisonBase(cwd);
+  if (baseline.baseSha !== null && !await commitExists(cwd, baseline.baseSha)) {
+    return resolveComparisonBase(cwd);
+  }
+  return { sha: baseline.baseSha ?? EMPTY_TREE_SHA, ref: SESSION_START_REF };
+}
+async function dropPreexisting(cwd, entries, baseline) {
+  if (baseline.preexisting.size === 0) return entries;
+  const untouched = await Promise.all(
+    entries.map(async (entry) => {
+      const before = baseline.preexisting.get(entry.path);
+      return before !== void 0 && before === await fingerprintFile(cwd, entry.path);
+    })
+  );
+  return entries.filter((_, index) => !untouched[index]);
+}
+function encodeBaseline(baseline) {
+  const serialized = {
+    v: 1,
+    base: baseline.baseSha,
+    files: [...baseline.preexisting]
+  };
+  return Buffer.from(JSON.stringify(serialized), "utf8").toString("base64url");
+}
+function isSerializedBaseline(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.v === 1 && (candidate.base === null || typeof candidate.base === "string") && Array.isArray(candidate.files) && candidate.files.every(
+    (file) => Array.isArray(file) && file.length === 2 && typeof file[0] === "string" && typeof file[1] === "string"
+  );
+}
+function decodeBaseline(encoded) {
+  try {
+    const parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    if (!isSerializedBaseline(parsed)) return null;
+    return { baseSha: parsed.base, preexisting: new Map(parsed.files) };
+  } catch {
+    return null;
+  }
+}
+
 // src/sessions/git/status.ts
 async function getCurrentBranch(cwd) {
   try {
@@ -2669,15 +2785,15 @@ function parseNameStatus(output) {
   }
   return changed;
 }
-async function getWorkspaceStatus(cwd) {
+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 resolveComparisonBase(cwd);
+  const base = await resolveBaseFor(cwd, baseline);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
-    runGitDiff(["--name-status", "-z", "-M", base.sha], cwd),
-    runGitDiff(["--numstat", "-z", "-M", base.sha], cwd),
+    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)
   ]);
   const numstat = parseNumstat(numstatRaw);
@@ -2701,14 +2817,20 @@ async function getWorkspaceStatus(cwd) {
     deletions: null,
     binary: false
   }));
-  return { isGitRepo: true, branch, baseRef: base.ref, files: [...tracked, ...untracked] };
+  const files = [...tracked, ...untracked];
+  return {
+    isGitRepo: true,
+    branch,
+    baseRef: base.ref,
+    files: baseline ? await dropPreexisting(cwd, files, baseline) : files
+  };
 }
-async function enrichSessionWithGitMetadata(session) {
+async function enrichSessionWithGitMetadata(session, baseline) {
   const [branch, repositoryFullName, status, lastActivityAt] = await Promise.all([
     getCurrentBranch(session.cwd),
     getRepositoryFullName(session.cwd),
-    getWorkspaceStatus(session.cwd),
-    getPaneActivity(session.tmuxSessionName)
+    getWorkspaceStatus(session.cwd, baseline),
+    getSessionActivity(session.tmuxSessionName)
   ]);
   const changedFileCount = status.isGitRepo ? new Set(status.files.map((f) => f.path)).size : null;
   return {
@@ -2722,7 +2844,7 @@ async function enrichSessionWithGitMetadata(session) {
 
 // src/sessions/git/diff.ts
 async function withRenameSource(cwd, baseSha, path) {
-  const nameStatus = await runGitDiff(["--name-status", "-z", "-M", baseSha], cwd);
+  const nameStatus = await runGitDiff(["--relative", "--name-status", "-z", "-M", baseSha], cwd);
   const previousPath = parseNameStatus(nameStatus).find((c) => c.path === path)?.previousPath;
   return previousPath === void 0 ? [path] : [previousPath, path];
 }
@@ -2730,15 +2852,18 @@ async function isUntracked(cwd, path) {
   const out = await runGit(["ls-files", "--others", "--exclude-standard", "--", path], cwd);
   return out.trim() !== "";
 }
-async function getWorkspaceDiff(cwd, path, staged) {
-  const base = await resolveComparisonBase(cwd);
+async function getWorkspaceDiff(cwd, path, staged, baseline) {
+  const base = await resolveBaseFor(cwd, baseline);
   const pathspec = await withRenameSource(cwd, base.sha, path);
-  const numstat = await runGitDiff(["--numstat", "-M", base.sha, "--", ...pathspec], cwd);
+  const numstat = await runGitDiff(
+    ["--relative", "--numstat", "-M", base.sha, "--", ...pathspec],
+    cwd
+  );
   const binary = /^(-\t-\t)/.test(numstat.trim());
   if (binary) {
     return { path, staged, patch: null, binary: true };
   }
-  let patch = await runGitDiff(["-M", base.sha, "--", ...pathspec], cwd);
+  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
@@ -2932,10 +3057,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 join5 } from "path";
+import { join as join6 } from "path";
 var InvalidCwdError = class extends Error {
   constructor(cwd) {
     super(`working directory does not exist: ${cwd}`);
@@ -2943,7 +3100,7 @@ var InvalidCwdError = class extends Error {
   }
 };
 function worktreePathFor(sessionId) {
-  return join5(homedir5(), ".bondsmith", "worktrees", sessionId);
+  return join6(homedir5(), ".bondsmith", "worktrees", sessionId);
 }
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
@@ -2962,6 +3119,7 @@ async function createTmuxSession(input) {
   }
   const tmuxSessionName = tmuxSessionNameFor(input.id);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const baseline = await captureBaseline(cwd, { freshCheckout: worktreeOf !== null });
   await runTmux(["new-session", "-d", "-s", tmuxSessionName, "-c", cwd, input.command], {
     env: filterSpawnEnv(process.env)
   });
@@ -2973,6 +3131,15 @@ async function createTmuxSession(input) {
   if (worktreeOf) {
     await runTmux(["set-option", "-t", tmuxSessionName, "@bondsmith-worktree-of", worktreeOf]);
   }
+  if (baseline) {
+    await runTmux([
+      "set-option",
+      "-t",
+      tmuxSessionName,
+      "@bondsmith-baseline",
+      encodeBaseline(baseline)
+    ]);
+  }
   const session = {
     id: input.id,
     title: input.title,
@@ -2987,7 +3154,7 @@ async function createTmuxSession(input) {
     changedFileCount: null,
     worktreeOf
   };
-  return enrichSessionWithGitMetadata(session);
+  return { session: await enrichSessionWithGitMetadata(session, baseline), baseline };
 }
 async function stopTmuxSession(tmuxSessionName) {
   await runTmux(["kill-session", "-t", tmuxSessionName]);
@@ -2995,6 +3162,7 @@ async function stopTmuxSession(tmuxSessionName) {
 
 // src/sessions/tmux/parse.ts
 var FIELD_COUNT = 7;
+var BASELINE_FIELD_INDEX = 7;
 function parseTmuxSessions(output) {
   const sessions = [];
   for (const line of output.split("\n")) {
@@ -3024,6 +3192,19 @@ function parseTmuxSessions(output) {
   }
   return sessions;
 }
+function parseSessionBaselines(output) {
+  const baselines = /* @__PURE__ */ new Map();
+  for (const line of output.split("\n")) {
+    const fields = line.split("	");
+    const sessionName = fields[0];
+    const id = fields[1];
+    const encoded = fields[BASELINE_FIELD_INDEX];
+    if (!sessionName || !isBondsmithTmuxSessionName(sessionName) || !id || !encoded) continue;
+    const baseline = decodeBaseline(encoded);
+    if (baseline) baselines.set(id, baseline);
+  }
+  return baselines;
+}
 
 // src/sessions/tmux/discover.ts
 var LIST_FORMAT = [
@@ -3033,15 +3214,21 @@ var LIST_FORMAT = [
   "#{@bondsmith-command}",
   "#{@bondsmith-cwd}",
   "#{@bondsmith-started-at}",
-  "#{@bondsmith-worktree-of}"
+  "#{@bondsmith-worktree-of}",
+  "#{@bondsmith-baseline}"
 ].join("	");
 async function discoverSessions() {
   try {
     const output = await listTmuxSessions(LIST_FORMAT);
-    const sessions = parseTmuxSessions(output);
-    return Promise.all(sessions.map((session) => enrichSessionWithGitMetadata(session)));
+    const baselines = parseSessionBaselines(output);
+    const sessions = await Promise.all(
+      parseTmuxSessions(output).map(
+        (session) => enrichSessionWithGitMetadata(session, baselines.get(session.id))
+      )
+    );
+    return { sessions, baselines };
   } catch (error2) {
-    if (error2 instanceof TmuxNoServerRunningError) return [];
+    if (error2 instanceof TmuxNoServerRunningError) return { sessions: [], baselines: /* @__PURE__ */ new Map() };
     if (error2 instanceof TmuxNotFoundError) {
       console.error(`
 ${error2.message}
@@ -3055,13 +3242,19 @@ ${error2.message}
 // src/sessions/session-manager.ts
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
+  // What each session's folder looked like when it started, so its file list shows only its own changes.
+  baselines = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   async initialize() {
     const discovered = await discoverSessions();
     this.sessions.clear();
-    for (const session of discovered) {
+    this.baselines.clear();
+    for (const session of discovered.sessions) {
       this.sessions.set(session.id, session);
     }
+    for (const [id, baseline] of discovered.baselines) {
+      this.baselines.set(id, baseline);
+    }
   }
   list() {
     return Array.from(this.sessions.values());
@@ -3069,6 +3262,10 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  /** Undefined for a session started before baselines existed, which compares against the default branch. */
+  getBaseline(sessionId) {
+    return this.baselines.get(sessionId);
+  }
   onSessionUpdated(listener) {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -3078,8 +3275,9 @@ var SessionManager = class {
   }
   async create(input) {
     const id = uuidv4();
-    const session = await createTmuxSession({ id, ...input });
+    const { session, baseline } = await createTmuxSession({ id, ...input });
     this.sessions.set(id, session);
+    if (baseline) this.baselines.set(id, baseline);
     return session;
   }
   async stop(sessionId) {
@@ -3114,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}
@@ -3134,13 +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(session);
-          if (!gitSnapshotEquals(session, updated)) {
+          const enriched = await enrichSessionWithGitMetadata(
+            session,
+            this.baselines.get(session.id)
+          );
+          const updated = {
+            ...enriched,
+            agentState: resolveSessionAttention(
+              agentReports.get(session.tmuxSessionName),
+              enriched.lastActivityAt
+            )
+          };
+          if (!snapshotEquals(session, updated)) {
             this.sessions.set(session.id, updated);
             this.emitUpdated(updated);
           }
@@ -3156,12 +3363,13 @@ ${error2.message}
   removeAsExited(session) {
     const updated = { ...session, status: "exited" };
     this.sessions.delete(session.id);
+    this.baselines.delete(session.id);
     this.emitUpdated(updated);
     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
@@ -3316,10 +3524,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join6(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join6(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join6(repoRoot, ".env.local");
-  const envDefault = join6(repoRoot, ".env");
+  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");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();

package/package.json

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