@bondsmith/bondsmithd 0.1.13 → 0.1.15

package/README.md

@@ -82,20 +82,20 @@ that pane belongs to:
 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 value is `<state>:<epoch seconds>`, where state is `working`, `waiting` (needs the user) or `done` (finished a turn, shown until the user attaches, types or resizes after it).
 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 dropped once the
 pane has been silent for 2 minutes, since an interrupted or crashed agent never reports again.
 
 Claude Code sessions that Bondsmith starts as plain `claude` report this on their own (see the end of the
-plan section below): `working` when a prompt is sent, `waiting` when it asks for permission, finishes a
-turn or fails with an API error. Nothing needs installing for those.
+plan section below): `working` when a prompt is sent, `waiting` when it asks for permission or fails with
+an API error, `done` when it finishes a turn. Nothing needs installing for those.
 
 For an agent the daemon does not set up (a wrapper, `npx claude`, another agent), note that every session
 Bondsmith starts has `BONDSMITH_SESSION` set to its id, so a hook installed once for all your projects can
 stay silent everywhere else. This entry in `~/.claude/settings.json` reports a Claude Code session as
-waiting the moment it asks for permission or finishes a turn:
+waiting the moment it asks for permission, and as done when it finishes a turn:
 
 ```json
 {
@@ -116,7 +116,7 @@ waiting the moment it asks for permission or finishes a turn:
 				"hooks": [
 					{
 						"type": "command",
-						"command": "[ -n \"$BONDSMITH_SESSION\" ] && tmux set-option -t \"$TMUX_PANE\" -q @bondsmith-agent-state \"waiting:$(date +%s)\"; exit 0"
+						"command": "[ -n \"$BONDSMITH_SESSION\" ] && tmux set-option -t \"$TMUX_PANE\" -q @bondsmith-agent-state \"done:$(date +%s)\"; exit 0"
 					}
 				]
 			}
@@ -127,7 +127,7 @@ waiting the moment it asks for permission or finishes a turn:
 
 This is optional, and nothing edits your settings for you. The command does nothing outside a Bondsmith
 session, and sessions started before the daemon set the variable are skipped by it. It reports only
-`waiting`. A `working` report is dropped after the pane has been silent for 2 minutes, so one that an
+`waiting` and `done`. A `working` report is dropped after the pane has been silent for 2 minutes, so one that an
 interrupted Claude Code never clears (it does not run `Stop` then, and has no hook for Escape) expires on
 its own.
 
@@ -157,6 +157,11 @@ that only answers the agent (`yes`, `continue`, `ok`, `thanks`, and a few like t
 characters leaves the earlier headline in place; a built-in slash command such as `/help` sends no prompt to
 the hook, so it does too. The prompt is stored as typed, so a secret in a prompt is in the headline.
 
+A sixth hook watches Bash calls for `gh pr create`. When one succeeds and prints a pull request URL, the URL is
+appended to the tmux option `@bondsmith-prs` (space separated, each once, the newest 20 kept), and the daemon
+reports it on the session as `pullRequestUrls`. It matches `gh pr create` only as a command of its own, so
+`echo "gh pr create"` or `gh pr view` record nothing, and a failed command never reaches it.
+
 The daemon leaves the command alone if it already has `--settings`, if the installed `claude` does not list
 `--settings` in `claude --help` (asked once per daemon run; if `claude` cannot be run at all, that is logged
 and asked again after a minute), or if `BONDSMITH_AGENT_HOOKS` is set to `off`, `0`, `false` or `no` where

package/dist/index.js

@@ -10,13 +10,15 @@ 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;
+var MAX_SESSION_PULL_REQUESTS = 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 = 16;
+var PROTOCOL_VERSION = 19;
 
 // ../../packages/local-agent-protocol/src/branch-name.ts
 var MAX_BRANCH_NAME_LENGTH = 250;
@@ -204,7 +206,9 @@ 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),
-  headline: z3.string().nullable().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),
+  pullRequestUrls: z3.array(z3.string().max(300)).max(MAX_SESSION_PULL_REQUESTS).optional().catch(void 0)
 });
 var workspaceFileEntrySchema = z3.object({
   path: z3.string(),
@@ -315,6 +319,11 @@ var browserMessageSchema = z3.discriminatedUnion("type", [
     sessionId: z3.string(),
     ...terminalSizeSchema.shape
   }),
+  z3.object({
+    type: z3.literal("session.setMouseMode"),
+    sessionId: z3.string(),
+    enabled: z3.boolean()
+  }),
   z3.object({ type: z3.literal("session.stop"), sessionId: z3.string() }),
   z3.object({
     type: z3.literal("workspace.getStatus"),
@@ -525,6 +534,7 @@ var SIGNABLE_ACTIONS = [
   "session.input",
   "session.insertText",
   "session.resize",
+  "session.setMouseMode",
   "session.stop",
   "session.list",
   "workspace.getStatus",
@@ -1184,7 +1194,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;
@@ -1239,6 +1249,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";
@@ -1418,6 +1465,12 @@ async function runTmux(args, options) {
 async function sendKeysLiteral(tmuxSessionName, text) {
   await runTmux(["send-keys", "-t", tmuxSessionName, "-l", text]);
 }
+async function setMouseMode(tmuxSessionName, enabled) {
+  await runTmux(["set-option", "-t", tmuxSessionName, "mouse", enabled ? "on" : "off"]);
+}
+async function cancelCopyMode(tmuxSessionName) {
+  await runTmux(["copy-mode", "-q", "-t", tmuxSessionName]);
+}
 async function capturePane(tmuxSessionName) {
   return runTmux(["capture-pane", "-t", tmuxSessionName, "-p", "-e"]);
 }
@@ -2229,7 +2282,7 @@ function listInstalledAgents(env = process.env) {
 }
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.13" : "dev";
+var DAEMON_VERSION = true ? "0.1.15" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -2406,6 +2459,7 @@ function verifyRejectionMessage(reason) {
 var REVOKED_REJECTION_MESSAGE = "connection has not completed its handshake";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
+var WHEEL_ONLY_INPUT = /^(?:\x1b\[<6[45];\d+;\d+M)+$/;
 function releaseSession(conn, ptyAttachments, sessionId) {
   const listener = conn.getOutputListener(sessionId);
   if (listener) ptyAttachments.release(sessionId, listener);
@@ -2419,6 +2473,7 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
   let admissionChain = Promise.resolve();
   const conn = {
     subscriptions: /* @__PURE__ */ new Set(),
+    mouseModeSessions: /* @__PURE__ */ new Map(),
     send,
     bufferedBytes,
     isClosed: () => closed,
@@ -2457,6 +2512,11 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
     for (const sessionId of [...conn.subscriptions]) {
       releaseSession(conn, ptyAttachments, sessionId);
     }
+    for (const tmuxSessionName of conn.mouseModeSessions.values()) {
+      setMouseMode(tmuxSessionName, false).catch(() => {
+      });
+    }
+    conn.mouseModeSessions.clear();
   }
   return { conn, releaseAllSubscriptions };
 }
@@ -2690,6 +2750,11 @@ async function dispatch(conn, message, {
         return;
       }
       sessionManager.acknowledge(message.sessionId);
+      const tmuxSessionName = conn.mouseModeSessions.get(message.sessionId);
+      if (tmuxSessionName && !WHEEL_ONLY_INPUT.test(message.data)) {
+        await cancelCopyMode(tmuxSessionName).catch(() => {
+        });
+      }
       ptyAttachments.write(message.sessionId, message.data);
       return;
     }
@@ -2720,6 +2785,20 @@ async function dispatch(conn, message, {
       ptyAttachments.resize(message.sessionId, message.cols, message.rows);
       return;
     }
+    case "session.setMouseMode": {
+      const session = sessionManager.get(message.sessionId);
+      if (!session) return;
+      if (message.enabled) conn.mouseModeSessions.set(session.id, session.tmuxSessionName);
+      else conn.mouseModeSessions.delete(session.id);
+      try {
+        await setMouseMode(session.tmuxSessionName, message.enabled);
+        if (message.enabled && conn.isClosed()) await setMouseMode(session.tmuxSessionName, false);
+      } catch (err) {
+        if (message.enabled) conn.mouseModeSessions.delete(session.id);
+        console.warn(`bondsmithd: ${errorMessageOf(err, "failed to set mouse mode")}`);
+      }
+      return;
+    }
     case "session.stop": {
       try {
         if (!await sessionManager.stop(message.sessionId)) {
@@ -3934,11 +4013,27 @@ 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 PULL_REQUESTS_OPTION = "@bondsmith-prs";
+var PULL_REQUEST_URL = /https?:\/\/[^\s/]+\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
 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}}	#{${PULL_REQUESTS_OPTION}}	#{${HEADLINE_OPTION}}`;
 var AGENT_STATE_OUTPUT_GRACE_MS = 2e3;
 var FUTURE_REPORT_ALLOWANCE_MS = 2e3;
 var WORKING_SILENCE_MS = 12e4;
@@ -3950,29 +4045,48 @@ function cleanHeadline(raw) {
   if (!line) return null;
   return line.length > MAX_HEADLINE_CHARS ? `${line.slice(0, MAX_HEADLINE_CHARS - 1)}\u2026` : line;
 }
+function parsePullRequestUrls(raw) {
+  const urls = [...new Set(raw.match(PULL_REQUEST_URL) ?? [])];
+  return urls.slice(-MAX_SESSION_PULL_REQUESTS);
+}
 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 = "", setupFailed = "", ...headline] = line.split("	");
+    const [
+      sessionName,
+      agentState = "",
+      bell = "",
+      setupFailed = "",
+      setupSkipped = "",
+      pullRequests = "",
+      ...headline
+    ] = line.split("	");
     if (sessionName) {
       reports.set(sessionName, {
         agentState,
         bell: bell === "1",
         setupFailed: setupFailed === "1",
+        setupSkipped: decodeSkippedFiles(setupSkipped),
+        pullRequestUrls: parsePullRequestUrls(pullRequests),
         headline: cleanHeadline(headline.join(" "))
       });
     }
   }
   return reports;
 }
-function resolveAgentState(raw, lastActivityAt, nowMs = Date.now()) {
+function parseReport(raw) {
   if (!raw) return null;
   const [state, epoch] = raw.split(":");
   if (!state || !isAgentState(state) || !epoch || !/^\d+$/.test(epoch)) return null;
-  const reportedAtMs = Number(epoch) * 1e3;
+  return { state, reportedAtMs: Number(epoch) * 1e3 };
+}
+function resolveAgentState(raw, lastActivityAt, nowMs = Date.now()) {
+  const parsed = parseReport(raw);
+  if (!parsed) return null;
+  const { state, reportedAtMs } = parsed;
   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;
@@ -3992,9 +4106,16 @@ function hasSettled(lastActivityAt, acknowledgedAtMs, nowMs = Date.now()) {
   }
   return nowMs - lastActivityMs >= SETTLE_QUIET_MS;
 }
+var REPORT_ROUNDING_MS = 1e3;
+function isDoneAcknowledged(raw, acknowledgedAtMs) {
+  const reportedAtMs = parseReport(raw)?.reportedAtMs;
+  if (acknowledgedAtMs === null || reportedAtMs === void 0) return false;
+  return acknowledgedAtMs >= reportedAtMs + REPORT_ROUNDING_MS;
+}
 function resolveSessionAttention(report, lastActivityAt, { nowMs, acknowledgedAtMs = null } = {}) {
   if (report?.bell) return "waiting";
   const reported = resolveAgentState(report?.agentState, lastActivityAt, nowMs);
+  if (reported === "done" && isDoneAcknowledged(report?.agentState, acknowledgedAtMs)) return null;
   if (reported) return reported;
   return hasSettled(lastActivityAt, acknowledgedAtMs, nowMs) ? "waiting" : null;
 }
@@ -4045,6 +4166,21 @@ function headlineHookScript() {
     `}catch{}})`
   ].join("");
 }
+var PR_CREATE_COMMAND = /(?:^|[;&|\n(])\s*(?:\w+=\S*\s+)*gh\s+pr\s+create\b/;
+function pullRequestHookScript() {
+  return [
+    `let d="";`,
+    `process.stdin.on("data",c=>d+=c).on("end",()=>{try{`,
+    `const j=JSON.parse(d),c=j.tool_input?.command,o=j.tool_response?.stdout;`,
+    `if(typeof c!=="string"||typeof o!=="string"||!${PR_CREATE_COMMAND.toString()}.test(c))return;`,
+    `const m=o.match(${PULL_REQUEST_URL.toString()});if(!m)return;const u=m[m.length-1];`,
+    `const cp=require("child_process"),p=process.env.TMUX_PANE;`,
+    `const cur=cp.execFileSync("tmux",["show-options","-qv","-t",p,"${PULL_REQUESTS_OPTION}"],{encoding:"utf8"}).split(/\\s+/).filter(Boolean);`,
+    `if(cur.includes(u))return;`,
+    `cp.execFileSync("tmux",["set-option","-t",p,"-q","${PULL_REQUESTS_OPTION}",cur.concat(u).slice(-${MAX_SESSION_PULL_REQUESTS}).join(" ")])`,
+    `}catch{}})`
+  ].join("");
+}
 
 // src/sessions/agents/claude-settings.ts
 function shellQuote3(value) {
@@ -4059,12 +4195,17 @@ function planHookCommand(nodePath = process.execPath, plansDir = HOOK_PLANS_DIR)
 function headlineHookCommand(nodePath = process.execPath) {
   return nodeHookCommand(headlineHookScript(), nodePath);
 }
+function pullRequestHookCommand(nodePath = process.execPath) {
+  const run = `${shellQuote3(nodePath)} -e ${shellQuote3(pullRequestHookScript())}`;
+  return `[ -n "$${SESSION_ENV_VAR}" ] && { input=$(cat); case "$input" in *"gh pr create"*) printf '%s' "$input" | ${run};; esac; }; exit 0`;
+}
 function stateHookCommand(state) {
   return `[ -n "$${SESSION_ENV_VAR}" ] && tmux set-option -t "$TMUX_PANE" -q ${AGENT_STATE_OPTION} "${state}:$(date +%s)"; exit 0`;
 }
 var STATE_HOOK_TIMEOUT_SECONDS = 5;
 var PLAN_HOOK_TIMEOUT_SECONDS = 10;
 var HEADLINE_HOOK_TIMEOUT_SECONDS = 5;
+var PULL_REQUEST_HOOK_TIMEOUT_SECONDS = 5;
 function claudeSettings() {
   const run = (command, timeout) => ({ type: "command", command, timeout });
   const report = (state) => run(stateHookCommand(state), STATE_HOOK_TIMEOUT_SECONDS);
@@ -4074,16 +4215,20 @@ function claudeSettings() {
         {
           matcher: "ExitPlanMode",
           hooks: [run(planHookCommand(), PLAN_HOOK_TIMEOUT_SECONDS)]
+        },
+        {
+          matcher: "Bash",
+          hooks: [run(pullRequestHookCommand(), PULL_REQUEST_HOOK_TIMEOUT_SECONDS)]
         }
       ],
-      // Working from the moment a prompt is sent, which is also the task the session is on; waiting whenever the user is next to act.
+      // Working from the moment a prompt is sent, which is also the task the session is on; waiting when it needs the user; done when a turn ends.
       UserPromptSubmit: [
         {
           hooks: [report("working"), run(headlineHookCommand(), HEADLINE_HOOK_TIMEOUT_SECONDS)]
         }
       ],
       PermissionRequest: [{ matcher: "*", hooks: [report("waiting")] }],
-      Stop: [{ hooks: [report("waiting")] }],
+      Stop: [{ hooks: [report("done")] }],
       StopFailure: [{ hooks: [report("waiting")] }]
     }
   };
@@ -4190,19 +4335,74 @@ async function resolveWorktreeStartPoint(sourceCwd, baseBranch) {
 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 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) {
@@ -4216,15 +4416,24 @@ async function copyFilesIntoWorktree(sourceRoot, worktreeRoot, globs) {
   }
   return result;
 }
-async function copyOne(source, worktree, 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;
+  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, constants4.COPYFILE_EXCL);
+    await copyFile(join10(source, match), to, constants4.COPYFILE_EXCL);
   } catch (error2) {
     if (error2.code === "EEXIST") return false;
     throw error2;
@@ -4247,6 +4456,7 @@ async function createTmuxSession(input) {
   let cwd = sourceCwd;
   let worktreeOf = null;
   let setupFailed = false;
+  let skippedFiles = [];
   if (input.worktreeBranch) {
     const worktreePath = worktreePathFor(input.id);
     const startPoint = await resolveWorktreeStartPoint(sourceCwd, input.baseBranch);
@@ -4260,6 +4470,7 @@ async function createTmuxSession(input) {
         input.worktreeSetup.copyGlobs
       );
       setupFailed = copy.failed > 0;
+      skippedFiles = copy.skipped;
     }
   }
   try {
@@ -4297,6 +4508,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",
@@ -4319,7 +4539,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 };
 }
@@ -4515,17 +4738,16 @@ ${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?.pullRequestUrls?.length && { pullRequestUrls: report.pullRequestUrls },
+            ...report?.setupFailed && { worktreeSetupFailed: true },
+            ...report?.setupSkipped?.length && { worktreeSetupSkipped: report.setupSkipped }
           };
           if (!snapshotEquals(session, updated)) {
             this.sessions.set(session.id, updated);
@@ -4550,7 +4772,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) && JSON.stringify(a.pullRequestUrls ?? []) === JSON.stringify(b.pullRequestUrls ?? []) && (a.worktreeSetupFailed ?? false) === (b.worktreeSetupFailed ?? false) && JSON.stringify(a.worktreeSetupSkipped ?? []) === JSON.stringify(b.worktreeSetupSkipped ?? []);
 }
 
 // src/ws/server.ts

package/package.json

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