@bondsmith/bondsmithd 0.1.12 → 0.1.14

package/dist/index.js

@@ -4,19 +4,28 @@
 import { createServer } from "http";
 import { existsSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { dirname as dirname5, join as join11 } from "path";
+import { dirname as dirname5, join as join12 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/local-agent-protocol/src/session.ts
 var SESSION_STATUSES = ["running", "exited"];
 var AGENT_STATES = ["working", "waiting", "done"];
+var MAX_SKIPPED_FILES_REPORTED = 20;
 
 // ../../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 = 14;
+var PROTOCOL_VERSION = 17;
+
+// ../../packages/local-agent-protocol/src/branch-name.ts
+var MAX_BRANCH_NAME_LENGTH = 250;
+var BRANCH_CHARACTERS = /^[\p{L}\p{N}._/+#@-]+$/u;
+var REJECTED_SHAPES = /^[-/]|\/\/|\.\.|@\{|^@$|[/.]$|(^|\/)\.|\.lock(\/|$)/;
+function isValidBranchName(name) {
+  return name.length > 0 && name.length <= MAX_BRANCH_NAME_LENGTH && BRANCH_CHARACTERS.test(name) && !REJECTED_SHAPES.test(name);
+}
 
 // ../../packages/local-agent-protocol/src/worktree-setup.ts
 var MAX_COPY_GLOBS = 50;
@@ -196,6 +205,7 @@ var localSessionSchema = z3.object({
   // .catch(undefined): a state this version doesn't know must never drop the whole session message.
   agentState: z3.enum(AGENT_STATES).nullable().optional().catch(void 0),
   worktreeSetupFailed: z3.boolean().optional().catch(void 0),
+  worktreeSetupSkipped: z3.array(z3.string().max(300)).max(MAX_SKIPPED_FILES_REPORTED).optional().catch(void 0),
   headline: z3.string().nullable().optional().catch(void 0)
 });
 var workspaceFileEntrySchema = z3.object({
@@ -271,6 +281,7 @@ var browserMessageSchema = z3.discriminatedUnion("type", [
     worktreeBranch: z3.string().min(1).max(250).refine((value) => !value.startsWith("-"), {
       message: "branch name can't start with -"
     }).optional(),
+    baseBranch: z3.string().max(MAX_BRANCH_NAME_LENGTH).refine(isValidBranchName).optional(),
     worktreeSetup: worktreeSetupSchema.optional(),
     requestId: z3.string().min(1).max(200).optional()
   }),
@@ -456,7 +467,8 @@ var daemonMessageSchema = z3.discriminatedUnion("type", [
     expiresAt: z3.number().int().positive(),
     // .catch(undefined): a malformed informational field must never fail the whole handshake message.
     protocolVersion: z3.number().int().positive().optional().catch(void 0),
-    daemonVersion: z3.string().optional().catch(void 0)
+    daemonVersion: z3.string().optional().catch(void 0),
+    installedAgents: z3.array(z3.string().max(40)).max(20).optional().catch(void 0)
   }),
   z3.object({
     type: z3.literal("connection.authenticated"),
@@ -1174,7 +1186,7 @@ function expandHome(cwd) {
 }
 
 // src/sessions/git/client.ts
-import { execFile as execFileCb } from "child_process";
+import { execFile as execFileCb, spawn as spawn2 } from "child_process";
 import { promisify } from "util";
 var execFile = promisify(execFileCb);
 var MAX_GIT_OUTPUT_BYTES = 64 * 1024 * 1024;
@@ -1229,6 +1241,43 @@ function runGitDiff(args, cwd) {
 function runGitDiffAllowingExitCodes(args, cwd, allowedExitCodes) {
   return runGitAllowingExitCodes(["diff", ...SAFE_DIFF_FLAGS, ...args], cwd, allowedExitCodes);
 }
+var GIT_INPUT_TIMEOUT_MS = 3e4;
+async function runGitWithInput(args, cwd, input, options = {}) {
+  const { allowedExitCodes = [], timeoutMs = GIT_INPUT_TIMEOUT_MS } = options;
+  return new Promise((resolve2, reject) => {
+    const child = spawn2("git", [...SAFE_GIT_CONFIG, ...args], { cwd });
+    const stdout = [];
+    const stderr = [];
+    let settled = false;
+    const settle = (finish) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      finish();
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      settle(() => reject(new Error(`git ${args[0]} timed out after ${timeoutMs} ms`)));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.stdin.on("error", () => {
+    });
+    child.on("error", (error2) => settle(() => reject(error2)));
+    child.on(
+      "close",
+      (code) => settle(() => {
+        if (code === 0 || code !== null && allowedExitCodes.includes(code)) {
+          resolve2(Buffer.concat(stdout).toString("utf8"));
+          return;
+        }
+        const message = Buffer.concat(stderr).toString("utf8").trim();
+        reject(new Error(`git ${args[0]} exited with ${code}${message ? `: ${message}` : ""}`));
+      })
+    );
+    child.stdin.end(input);
+  });
+}
 
 // src/sessions/files/plan-file.ts
 import { constants as constants2 } from "fs";
@@ -1542,12 +1591,28 @@ async function commitExists(cwd, sha) {
     return false;
   }
 }
+async function isAncestor(cwd, ancestor, descendant) {
+  try {
+    await runGit(["merge-base", "--is-ancestor", ancestor, descendant], cwd);
+    return true;
+  } catch (error2) {
+    if (error2.code === 1) return false;
+    throw error2;
+  }
+}
 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 };
+  const start2 = {
+    sha: baseline.baseSha ?? EMPTY_TREE_SHA,
+    ref: SESSION_START_REF
+  };
+  if (baseline.baseSha === null) return start2;
+  const meeting = await resolveComparisonBase(cwd);
+  if (meeting.ref === null || await isAncestor(cwd, meeting.sha, baseline.baseSha)) return start2;
+  return meeting;
 }
 async function dropPreexisting(cwd, entries, baseline) {
   if (baseline.preexisting.size === 0) return entries;
@@ -2183,8 +2248,27 @@ var ConnectionAuthState = class {
   }
 };
 
+// src/sessions/agents/installed-agents.ts
+import { accessSync, constants as constants3, statSync } from "fs";
+import { delimiter, join as join6 } from "path";
+var KNOWN_AGENTS = ["claude", "codex", "opencode"];
+function isExecutableFile(path) {
+  try {
+    accessSync(path, constants3.X_OK);
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function listInstalledAgents(env = process.env) {
+  const directories = (env.PATH ?? "").split(delimiter).filter((directory) => directory !== "");
+  return KNOWN_AGENTS.filter(
+    (agent) => directories.some((directory) => isExecutableFile(join6(directory, agent)))
+  );
+}
+
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.12" : "dev";
+var DAEMON_VERSION = true ? "0.1.14" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -2555,13 +2639,14 @@ async function dispatch(conn, message, {
       return;
     }
     case "session.create": {
-      const { title, cwd, command, worktreeBranch, worktreeSetup, requestId } = message;
+      const { title, cwd, command, worktreeBranch, baseBranch, worktreeSetup, requestId } = message;
       try {
         const session = await sessionManager.create({
           title,
           cwd,
           command,
           worktreeBranch,
+          baseBranch,
           worktreeSetup
         });
         broadcast({ type: "session.created", session, requestId });
@@ -2997,7 +3082,8 @@ function startRelayClient(deps) {
       hostname: deps.hostname(),
       expiresAt: challenge.expiresAt,
       protocolVersion: PROTOCOL_VERSION,
-      daemonVersion: DAEMON_VERSION
+      daemonVersion: DAEMON_VERSION,
+      installedAgents: listInstalledAgents()
     });
   }
   function handleFrame(frame) {
@@ -3137,9 +3223,9 @@ function startRelayClient(deps) {
 import { generateKeyPairSync, sign as sign2, verify as verify4 } from "crypto";
 import { mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 function defaultCredentialsPath() {
-  return join6(homedir4(), ".bondsmith", "credentials");
+  return join7(homedir4(), ".bondsmith", "credentials");
 }
 async function loadOrCreateDaemonIdentity(credentialsPath = defaultCredentialsPath()) {
   const existing = await tryReadIdentity(credentialsPath);
@@ -3208,9 +3294,9 @@ function createDaemonProofSigner(privateKeyPem) {
 import { randomBytes as randomBytes2 } from "crypto";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 function defaultDevTunnelTokenPath() {
-  return join7(homedir5(), ".bondsmith", "dev-tunnel-token");
+  return join8(homedir5(), ".bondsmith", "dev-tunnel-token");
 }
 async function loadOrCreateDevTunnelToken(tokenPath = defaultDevTunnelTokenPath()) {
   const existing = await tryReadToken(tokenPath);
@@ -3834,11 +3920,11 @@ function stderrOf(error2) {
   const stderr = error2.stderr;
   return typeof stderr === "string" ? stderr : "";
 }
-async function createWorktree(sourceCwd, worktreePath, branch) {
+async function createWorktree(sourceCwd, worktreePath, branch, startPoint) {
+  const args = ["worktree", "add", "--no-track", "-b", branch, worktreePath];
+  if (startPoint) args.push(startPoint);
   try {
-    await execFile3("git", [...SAFE_GIT_CONFIG, "worktree", "add", "-b", branch, worktreePath], {
-      cwd: sourceCwd
-    });
+    await execFile3("git", [...SAFE_GIT_CONFIG, ...args], { cwd: sourceCwd });
   } catch (error2) {
     const stderr = stderrOf(error2);
     if (stderr.includes("a branch named")) {
@@ -3887,11 +3973,25 @@ function wrapCommandWithSetup(input) {
   ].join(" ");
 }
 
+// src/sessions/worktree-setup/skipped-files.ts
+var SETUP_SKIPPED_OPTION = "@bondsmith-setup-skipped";
+function encodeSkippedFiles(names) {
+  return names.slice(0, MAX_SKIPPED_FILES_REPORTED).map(encodeURIComponent).join(",");
+}
+function decodeSkippedFiles(raw) {
+  if (raw === "") return [];
+  try {
+    return raw.split(",").map(decodeURIComponent);
+  } catch {
+    return [];
+  }
+}
+
 // src/sessions/tmux/agent-state.ts
 var AGENT_STATE_OPTION = "@bondsmith-agent-state";
 var HEADLINE_OPTION = "@bondsmith-headline";
 var MAX_HEADLINE_CHARS = 200;
-var LIVE_SESSION_REPORTS_FORMAT = `#{session_name}	#{${AGENT_STATE_OPTION}}	#{window_bell_flag}	#{${SETUP_FAILED_OPTION}}	#{${HEADLINE_OPTION}}`;
+var LIVE_SESSION_REPORTS_FORMAT = `#{session_name}	#{${AGENT_STATE_OPTION}}	#{window_bell_flag}	#{${SETUP_FAILED_OPTION}}	#{${SETUP_SKIPPED_OPTION}}	#{${HEADLINE_OPTION}}`;
 var AGENT_STATE_OUTPUT_GRACE_MS = 2e3;
 var FUTURE_REPORT_ALLOWANCE_MS = 2e3;
 var WORKING_SILENCE_MS = 12e4;
@@ -3909,12 +4009,20 @@ function isAgentState(value) {
 function parseLiveSessionReports(output) {
   const reports = /* @__PURE__ */ new Map();
   for (const line of output.split("\n")) {
-    const [sessionName, agentState = "", bell = "", setupFailed = "", ...headline] = line.split("	");
+    const [
+      sessionName,
+      agentState = "",
+      bell = "",
+      setupFailed = "",
+      setupSkipped = "",
+      ...headline
+    ] = line.split("	");
     if (sessionName) {
       reports.set(sessionName, {
         agentState,
         bell: bell === "1",
         setupFailed: setupFailed === "1",
+        setupSkipped: decodeSkippedFiles(setupSkipped),
         headline: cleanHeadline(headline.join(" "))
       });
     }
@@ -3955,14 +4063,14 @@ function resolveSessionAttention(report, lastActivityAt, { nowMs, acknowledgedAt
 // src/sessions/tmux/create.ts
 import { access } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/sessions/agents/claude-hooks.ts
 import { execFile as execFile4 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir4, rename as rename4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { promisify as promisify4 } from "util";
 
 // src/sessions/session-env.ts
@@ -4044,7 +4152,7 @@ function claudeSettings() {
 
 // src/sessions/agents/claude-hooks.ts
 var execFileAsync = promisify4(execFile4);
-var CLAUDE_HOOKS_DIR = join8(homedir6(), ".bondsmith", "hooks");
+var CLAUDE_HOOKS_DIR = join9(homedir6(), ".bondsmith", "hooks");
 var AGENT_HOOKS_ENV_VAR = "BONDSMITH_AGENT_HOOKS";
 var HOOKS_OFF_VALUES = /^(off|0|false|no)$/i;
 var CLAUDE_BINARY = "claude";
@@ -4096,7 +4204,7 @@ async function prepareAgentCommand(command, {
   if (HOOKS_OFF_VALUES.test(env[AGENT_HOOKS_ENV_VAR] ?? "")) return command;
   if (!isPlainClaudeCommand(command)) return command;
   if (!await supportsSettings()) return command;
-  const file = join8(hooksDir, "claude-settings.json");
+  const file = join9(hooksDir, "claude-settings.json");
   const staging = `${file}.${randomUUID2()}.tmp`;
   try {
     await mkdir4(hooksDir, { recursive: true });
@@ -4116,23 +4224,101 @@ async function prepareAgentCommand(command, {
   );
 }
 
+// src/sessions/git/start-point.ts
+var WorktreeBaseBranchNotFoundError = class extends Error {
+  constructor(branch) {
+    super(`base branch "${branch}" was not found (looked for origin/${branch} and ${branch})`);
+    this.name = "WorktreeBaseBranchNotFoundError";
+  }
+};
+async function commitExists2(ref, cwd) {
+  try {
+    await runGit(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveWorktreeStartPoint(sourceCwd, baseBranch) {
+  if (baseBranch === void 0) return await findDefaultBranchRef(sourceCwd) ?? void 0;
+  for (const candidate of [`origin/${baseBranch}`, baseBranch]) {
+    if (await commitExists2(candidate, sourceCwd)) return candidate;
+  }
+  throw new WorktreeBaseBranchNotFoundError(baseBranch);
+}
+
 // src/sessions/worktree-setup/copy-files.ts
-import { constants as constants3 } from "fs";
+import { constants as constants4 } from "fs";
 import { copyFile, glob, lstat as lstat3, mkdir as mkdir5, realpath as realpath2 } from "fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join9, relative, sep as sep2 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join10, relative, sep as sep2 } from "path";
+var GIT_EXIT_NONE_IGNORED = 1;
+var TRACKED_CHECK_BATCH = 200;
 function isInside(root, path) {
   const rel = relative(root, path);
   return rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute3(rel);
 }
+async function ignoredPaths(worktree, paths) {
+  if (paths.length === 0) return /* @__PURE__ */ new Set();
+  const output = await runGitWithInput(
+    ["check-ignore", "--stdin", "-z"],
+    worktree,
+    paths.map((path) => `${path}\0`).join(""),
+    { allowedExitCodes: [GIT_EXIT_NONE_IGNORED] }
+  );
+  return new Set(output.split("\0").filter((path) => path !== ""));
+}
+async function trackedPaths(worktree, paths) {
+  const tracked = /* @__PURE__ */ new Set();
+  for (let start2 = 0; start2 < paths.length; start2 += TRACKED_CHECK_BATCH) {
+    const output = await runGit(
+      [
+        "--literal-pathspecs",
+        "ls-files",
+        "-z",
+        "--",
+        ...paths.slice(start2, start2 + TRACKED_CHECK_BATCH)
+      ],
+      worktree
+    );
+    for (const path of output.split("\0")) if (path !== "") tracked.add(path);
+  }
+  return tracked;
+}
 async function copyFilesIntoWorktree(sourceRoot, worktreeRoot, globs) {
-  const result = { copied: [], failed: 0 };
+  const result = { copied: [], failed: 0, skipped: [] };
   const patterns = globs.filter(isSafeCopyGlob);
   if (patterns.length === 0) return result;
   try {
     const source = await realpath2(sourceRoot);
     const worktree = await realpath2(worktreeRoot);
+    const candidates = [];
     for await (const match of glob(patterns, { cwd: source })) {
       if (match.split(sep2).includes(".git")) continue;
+      try {
+        if (await isCopyCandidate(source, worktree, match)) candidates.push(match);
+      } catch (error2) {
+        result.failed += 1;
+        console.error("Failed to inspect a file to copy into the worktree", { match, error: error2 });
+      }
+    }
+    let tracked;
+    let ignored;
+    try {
+      tracked = await trackedPaths(worktree, candidates);
+      ignored = await ignoredPaths(worktree, candidates);
+    } catch (error2) {
+      result.failed += candidates.length;
+      console.error("Could not ask git what the worktree tracks and ignores; copying nothing", {
+        error: error2
+      });
+      return result;
+    }
+    for (const match of candidates) {
+      if (tracked.has(match)) continue;
+      if (!ignored.has(match)) {
+        result.skipped.push(match);
+        continue;
+      }
       try {
         if (await copyOne(source, worktree, match)) result.copied.push(match);
       } catch (error2) {
@@ -4146,15 +4332,24 @@ async function copyFilesIntoWorktree(sourceRoot, worktreeRoot, globs) {
   }
   return result;
 }
-async function copyOne(source, worktree, match) {
-  const from = join9(source, match);
+async function isCopyCandidate(source, worktree, match) {
+  const from = join10(source, match);
   if (!(await lstat3(from)).isFile()) return false;
   if (!isInside(source, await realpath2(from))) return false;
-  const to = join9(worktree, match);
+  try {
+    await lstat3(join10(worktree, match));
+    return false;
+  } catch (error2) {
+    if (error2.code === "ENOENT") return true;
+    throw error2;
+  }
+}
+async function copyOne(source, worktree, match) {
+  const to = join10(worktree, match);
   await mkdir5(dirname4(to), { recursive: true });
   if (!isInside(worktree, await realpath2(dirname4(to)))) return false;
   try {
-    await copyFile(from, to, constants3.COPYFILE_EXCL);
+    await copyFile(join10(source, match), to, constants4.COPYFILE_EXCL);
   } catch (error2) {
     if (error2.code === "EEXIST") return false;
     throw error2;
@@ -4170,16 +4365,18 @@ var InvalidCwdError = class extends Error {
   }
 };
 function worktreePathFor(sessionId) {
-  return join10(homedir7(), ".bondsmith", "worktrees", sessionId);
+  return join11(homedir7(), ".bondsmith", "worktrees", sessionId);
 }
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
   let cwd = sourceCwd;
   let worktreeOf = null;
   let setupFailed = false;
+  let skippedFiles = [];
   if (input.worktreeBranch) {
     const worktreePath = worktreePathFor(input.id);
-    await createWorktree(sourceCwd, worktreePath, input.worktreeBranch);
+    const startPoint = await resolveWorktreeStartPoint(sourceCwd, input.baseBranch);
+    await createWorktree(sourceCwd, worktreePath, input.worktreeBranch, startPoint);
     cwd = worktreePath;
     worktreeOf = sourceCwd;
     if (input.worktreeSetup?.copyGlobs.length) {
@@ -4189,6 +4386,7 @@ async function createTmuxSession(input) {
         input.worktreeSetup.copyGlobs
       );
       setupFailed = copy.failed > 0;
+      skippedFiles = copy.skipped;
     }
   }
   try {
@@ -4226,6 +4424,15 @@ async function createTmuxSession(input) {
     await runTmux(["set-option", "-t", tmuxSessionName, "@bondsmith-worktree-of", worktreeOf]);
   }
   if (setupFailed) await runTmux(["set-option", "-t", tmuxSessionName, SETUP_FAILED_OPTION, "1"]);
+  if (skippedFiles.length > 0) {
+    await runTmux([
+      "set-option",
+      "-t",
+      tmuxSessionName,
+      SETUP_SKIPPED_OPTION,
+      encodeSkippedFiles(skippedFiles)
+    ]);
+  }
   if (baseline) {
     await runTmux([
       "set-option",
@@ -4248,7 +4455,10 @@ async function createTmuxSession(input) {
     lastActivityAt: null,
     changedFileCount: null,
     worktreeOf,
-    ...setupFailed && { worktreeSetupFailed: true }
+    ...setupFailed && { worktreeSetupFailed: true },
+    ...skippedFiles.length > 0 && {
+      worktreeSetupSkipped: skippedFiles.slice(0, MAX_SKIPPED_FILES_REPORTED)
+    }
   };
   return { session: await enrichSessionWithGitMetadata(session, baseline), baseline };
 }
@@ -4444,17 +4654,15 @@ ${error2.message}
             session,
             this.baselines.get(session.id)
           );
+          const report = agentReports.get(session.tmuxSessionName);
           const updated = {
             ...enriched,
-            agentState: resolveSessionAttention(
-              agentReports.get(session.tmuxSessionName),
-              enriched.lastActivityAt,
-              { acknowledgedAtMs: this.acknowledgements.get(session.id) ?? null }
-            ),
-            headline: agentReports.get(session.tmuxSessionName)?.headline ?? null,
-            ...agentReports.get(session.tmuxSessionName)?.setupFailed && {
-              worktreeSetupFailed: true
-            }
+            agentState: resolveSessionAttention(report, enriched.lastActivityAt, {
+              acknowledgedAtMs: this.acknowledgements.get(session.id) ?? null
+            }),
+            headline: report?.headline ?? null,
+            ...report?.setupFailed && { worktreeSetupFailed: true },
+            ...report?.setupSkipped?.length && { worktreeSetupSkipped: report.setupSkipped }
           };
           if (!snapshotEquals(session, updated)) {
             this.sessions.set(session.id, updated);
@@ -4479,7 +4687,7 @@ ${error2.message}
   }
 };
 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) && (a.headline ?? null) === (b.headline ?? null) && (a.worktreeSetupFailed ?? false) === (b.worktreeSetupFailed ?? false);
+  return a.branch === b.branch && a.repositoryFullName === b.repositoryFullName && a.changedFileCount === b.changedFileCount && a.lastActivityAt === b.lastActivityAt && (a.agentState ?? null) === (b.agentState ?? null) && (a.headline ?? null) === (b.headline ?? null) && (a.worktreeSetupFailed ?? false) === (b.worktreeSetupFailed ?? false) && JSON.stringify(a.worktreeSetupSkipped ?? []) === JSON.stringify(b.worktreeSetupSkipped ?? []);
 }
 
 // src/ws/server.ts
@@ -4580,7 +4788,8 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
       hostname: hostname(),
       expiresAt: challenge.expiresAt,
       protocolVersion: PROTOCOL_VERSION,
-      daemonVersion: DAEMON_VERSION
+      daemonVersion: DAEMON_VERSION,
+      installedAgents: listInstalledAgents()
     });
     const unauthenticatedTimer = setTimeout(() => {
       if (!connectionAuth.isAuthenticated()) socket.close();
@@ -4645,10 +4854,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join11(dirname5(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join11(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join11(repoRoot, ".env.local");
-  const envDefault = join11(repoRoot, ".env");
+  const repoRoot = join12(dirname5(fileURLToPath(import.meta.url)), "..", "..", "..");
+  if (!existsSync(join12(repoRoot, "pnpm-workspace.yaml"))) return;
+  const envLocal = join12(repoRoot, ".env.local");
+  const envDefault = join12(repoRoot, ".env");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();

package/package.json

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