@staff0rd/assist 0.886.1 → 0.886.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -6,7 +6,7 @@ import { Command } from "commander";
6
6
  // package.json
7
7
  var package_default = {
8
8
  name: "@staff0rd/assist",
9
- version: "0.886.1",
9
+ version: "0.886.3",
10
10
  type: "module",
11
11
  main: "dist/index.js",
12
12
  bin: {
@@ -358,9 +358,9 @@ var daemonPaths = {
358
358
 
359
359
  // src/commands/sessions/daemon/connectToDaemon.ts
360
360
  function connectToDaemon() {
361
- return new Promise((resolve30, reject) => {
361
+ return new Promise((resolve31, reject) => {
362
362
  const socket = net.connect(daemonPaths.socket);
363
- socket.once("connect", () => resolve30(socket));
363
+ socket.once("connect", () => resolve31(socket));
364
364
  socket.once("error", reject);
365
365
  });
366
366
  }
@@ -441,7 +441,7 @@ function spawnDaemon(reason4) {
441
441
  child.unref();
442
442
  }
443
443
  function delay(ms) {
444
- return new Promise((resolve30) => setTimeout(resolve30, ms));
444
+ return new Promise((resolve31) => setTimeout(resolve31, ms));
445
445
  }
446
446
 
447
447
  // src/shared/loadConfig.ts
@@ -1508,7 +1508,7 @@ var defaultDeps = {
1508
1508
  serve: async (args) => {
1509
1509
  await runTailscale(args);
1510
1510
  },
1511
- sleep: (ms) => new Promise((resolve30) => setTimeout(resolve30, ms)),
1511
+ sleep: (ms) => new Promise((resolve31) => setTimeout(resolve31, ms)),
1512
1512
  httpsPort: tailnetHttpsPort
1513
1513
  };
1514
1514
  async function ensureTailscaleServe(port, deps2 = {}) {
@@ -4055,12 +4055,12 @@ async function loadVisibleItems(req) {
4055
4055
 
4056
4056
  // src/commands/backlog/web/parseStatusBody.ts
4057
4057
  function readBody(req) {
4058
- return new Promise((resolve30, reject) => {
4058
+ return new Promise((resolve31, reject) => {
4059
4059
  let body = "";
4060
4060
  req.on("data", (chunk) => {
4061
4061
  body += chunk.toString();
4062
4062
  });
4063
- req.on("end", () => resolve30(body));
4063
+ req.on("end", () => resolve31(body));
4064
4064
  req.on("error", reject);
4065
4065
  });
4066
4066
  }
@@ -4976,11 +4976,11 @@ async function requestDaemonReply(request, replyType, timeoutMs = QUERY_TIMEOUT_
4976
4976
  } catch {
4977
4977
  return void 0;
4978
4978
  }
4979
- return new Promise((resolve30) => {
4979
+ return new Promise((resolve31) => {
4980
4980
  const finish2 = (result) => {
4981
4981
  clearTimeout(timer);
4982
4982
  socket.destroy();
4983
- resolve30(result);
4983
+ resolve31(result);
4984
4984
  };
4985
4985
  const timer = setTimeout(() => finish2(void 0), timeoutMs);
4986
4986
  const lines2 = createInterface3({ input: socket });
@@ -5160,7 +5160,7 @@ function parseIncoming(line, type) {
5160
5160
  }
5161
5161
  }
5162
5162
  function requestSession(message3) {
5163
- return new Promise((resolve30, reject) => {
5163
+ return new Promise((resolve31, reject) => {
5164
5164
  connectToDaemon().then((socket) => {
5165
5165
  let settled = false;
5166
5166
  const finish2 = (error, sessionId) => {
@@ -5168,7 +5168,7 @@ function requestSession(message3) {
5168
5168
  settled = true;
5169
5169
  socket.destroy();
5170
5170
  if (error) reject(error);
5171
- else resolve30(sessionId);
5171
+ else resolve31(sessionId);
5172
5172
  };
5173
5173
  readSocketLines(socket, (line) => {
5174
5174
  const incoming = parseIncoming(line, message3.type);
@@ -8785,7 +8785,7 @@ function forwardToPeer(req, res, node, url) {
8785
8785
  const label2 = `link ${node} http: ${req.method} ${url.pathname} trace=${traceId}`;
8786
8786
  const log2 = (outcome) => console.log(`${label2} -> ${outcome} (${Date.now() - started}ms)`);
8787
8787
  const send = url.protocol === "https:" ? httpsRequest : httpRequest;
8788
- return new Promise((resolve30) => {
8788
+ return new Promise((resolve31) => {
8789
8789
  const upstream = send(
8790
8790
  url,
8791
8791
  {
@@ -8797,7 +8797,7 @@ function forwardToPeer(req, res, node, url) {
8797
8797
  [TRACE_HEADER]: traceId
8798
8798
  }
8799
8799
  },
8800
- (peer) => relayPeerResponse(peer, res, url.pathname, log2, resolve30)
8800
+ (peer) => relayPeerResponse(peer, res, url.pathname, log2, resolve31)
8801
8801
  );
8802
8802
  boundUpstream(upstream, res, peerTimeoutFor(url.pathname));
8803
8803
  upstream.on("error", (error) => {
@@ -8807,7 +8807,7 @@ function forwardToPeer(req, res, node, url) {
8807
8807
  respondJson(res, 502, {
8808
8808
  error: `${node} unreachable: ${error.message}`
8809
8809
  });
8810
- resolve30();
8810
+ resolve31();
8811
8811
  });
8812
8812
  req.pipe(upstream);
8813
8813
  });
@@ -9548,17 +9548,17 @@ async function stopDaemon() {
9548
9548
  }
9549
9549
  }
9550
9550
  function closedBeforeTimeout(socket) {
9551
- return new Promise((resolve30) => {
9551
+ return new Promise((resolve31) => {
9552
9552
  const timer = setTimeout(() => {
9553
9553
  socket.destroy();
9554
- resolve30(false);
9554
+ resolve31(false);
9555
9555
  }, STOP_TIMEOUT_MS);
9556
9556
  socket.resume();
9557
9557
  socket.on("error", () => {
9558
9558
  });
9559
9559
  socket.once("close", () => {
9560
9560
  clearTimeout(timer);
9561
- resolve30(true);
9561
+ resolve31(true);
9562
9562
  });
9563
9563
  });
9564
9564
  }
@@ -9621,8 +9621,8 @@ async function restartWeb(req, res, deps2 = {}) {
9621
9621
  return;
9622
9622
  }
9623
9623
  console.log(`restart ${target} ${linkedRequester(req)}`);
9624
- await new Promise((resolve30) => {
9625
- res.once("finish", resolve30);
9624
+ await new Promise((resolve31) => {
9625
+ res.once("finish", resolve31);
9626
9626
  respondJson(res, 200, { ok: true });
9627
9627
  });
9628
9628
  try {
@@ -9777,8 +9777,8 @@ async function selfUpdate(req, res, deps2 = {}) {
9777
9777
  return;
9778
9778
  }
9779
9779
  console.log("self-update: updated; restarting daemon and web server");
9780
- await new Promise((resolve30) => {
9781
- res.once("finish", resolve30);
9780
+ await new Promise((resolve31) => {
9781
+ res.once("finish", resolve31);
9782
9782
  respondJson(res, 200, { ok: true });
9783
9783
  });
9784
9784
  await performRestart("both", restartDeps);
@@ -9879,14 +9879,14 @@ function linkWebSocketUrl(url) {
9879
9879
  return target.toString();
9880
9880
  }
9881
9881
  function connectLinkWebSocket(url, handlers) {
9882
- return new Promise((resolve30, reject) => {
9882
+ return new Promise((resolve31, reject) => {
9883
9883
  const ws = new WebSocket(linkWebSocketUrl(url), {
9884
9884
  handshakeTimeout: HANDSHAKE_TIMEOUT_MS
9885
9885
  });
9886
9886
  let open = false;
9887
9887
  ws.on("open", () => {
9888
9888
  open = true;
9889
- resolve30({
9889
+ resolve31({
9890
9890
  send: (line) => {
9891
9891
  if (ws.readyState !== WebSocket.OPEN) return false;
9892
9892
  ws.send(line);
@@ -9912,8 +9912,8 @@ var HELLO_TIMEOUT_MS = 5e3;
9912
9912
  async function probePeerHello(url) {
9913
9913
  let settle = () => {
9914
9914
  };
9915
- const reply2 = new Promise((resolve30) => {
9916
- settle = resolve30;
9915
+ const reply2 = new Promise((resolve31) => {
9916
+ settle = resolve31;
9917
9917
  });
9918
9918
  const socket = await connectLinkWebSocket(url, {
9919
9919
  onLine: (line) => {
@@ -11742,10 +11742,10 @@ function gitInvocation(cwd, args) {
11742
11742
  }
11743
11743
  function git(cwd, args) {
11744
11744
  const { file, argv, options: options2 } = gitInvocation(cwd, args);
11745
- return new Promise((resolve30, reject) => {
11745
+ return new Promise((resolve31, reject) => {
11746
11746
  execFile10(file, argv, options2, (error, stdout) => {
11747
11747
  if (error) reject(error);
11748
- else resolve30(stdout.toString());
11748
+ else resolve31(stdout.toString());
11749
11749
  });
11750
11750
  });
11751
11751
  }
@@ -13095,7 +13095,7 @@ ${failed3.length} script(s) failed:`);
13095
13095
  }
13096
13096
  }
13097
13097
  function runEntry(entry) {
13098
- return new Promise((resolve30) => {
13098
+ return new Promise((resolve31) => {
13099
13099
  const startTime = Date.now();
13100
13100
  const child = spawnCommand(
13101
13101
  entry.fullCommand,
@@ -13107,7 +13107,7 @@ function runEntry(entry) {
13107
13107
  child.on("close", (code) => {
13108
13108
  const exitCode = code ?? 1;
13109
13109
  flushIfFailed(exitCode, chunks);
13110
- resolve30({
13110
+ resolve31({
13111
13111
  script: entry.name,
13112
13112
  code: exitCode,
13113
13113
  durationMs: Date.now() - startTime
@@ -13971,7 +13971,7 @@ function parsePreviewDecision(line, requestId) {
13971
13971
 
13972
13972
  // src/commands/sessions/shared/requestPreviewDecision.ts
13973
13973
  function requestPreviewDecision(request) {
13974
- return new Promise((resolve30, reject) => {
13974
+ return new Promise((resolve31, reject) => {
13975
13975
  connectToDaemon().then((socket) => {
13976
13976
  let settled = false;
13977
13977
  const finish2 = (error, decision) => {
@@ -13979,7 +13979,7 @@ function requestPreviewDecision(request) {
13979
13979
  settled = true;
13980
13980
  socket.destroy();
13981
13981
  if (error) reject(error);
13982
- else resolve30(decision);
13982
+ else resolve31(decision);
13983
13983
  };
13984
13984
  readSocketLines(socket, (line) => {
13985
13985
  const incoming = parsePreviewDecision(line, request.requestId);
@@ -16412,8 +16412,8 @@ function spawnInherit(command, args, options2 = {}) {
16412
16412
  env: { ...env, ...options2.env },
16413
16413
  cwd: options2.cwd
16414
16414
  });
16415
- const done2 = new Promise((resolve30, reject) => {
16416
- child.on("close", (code) => resolve30(code ?? 0));
16415
+ const done2 = new Promise((resolve31, reject) => {
16416
+ child.on("close", (code) => resolve31(code ?? 0));
16417
16417
  child.on("error", reject);
16418
16418
  });
16419
16419
  return { child, done: done2 };
@@ -16832,7 +16832,7 @@ Failed to launch Claude for ${context}: ${message3}`)
16832
16832
  // src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
16833
16833
  var ACK_TIMEOUT_MS = 1e3;
16834
16834
  function sendToDaemonAwaitAck(message3) {
16835
- return new Promise((resolve30, reject) => {
16835
+ return new Promise((resolve31, reject) => {
16836
16836
  connectToDaemon().then((socket) => {
16837
16837
  let settled = false;
16838
16838
  const finish2 = (error) => {
@@ -16841,7 +16841,7 @@ function sendToDaemonAwaitAck(message3) {
16841
16841
  clearTimeout(timer);
16842
16842
  socket.destroy();
16843
16843
  if (error) reject(error);
16844
- else resolve30();
16844
+ else resolve31();
16845
16845
  };
16846
16846
  const timer = setTimeout(
16847
16847
  () => finish2(new Error("timed out awaiting daemon ack")),
@@ -16922,7 +16922,7 @@ async function deliver(sessionId, status2, payload, attempts) {
16922
16922
  }
16923
16923
  }
16924
16924
  function sleep(ms) {
16925
- return new Promise((resolve30) => setTimeout(resolve30, ms));
16925
+ return new Promise((resolve31) => setTimeout(resolve31, ms));
16926
16926
  }
16927
16927
  function describeError(error) {
16928
16928
  return error instanceof Error ? error.message : String(error);
@@ -20624,12 +20624,12 @@ function hasSubcommands(helpText) {
20624
20624
  // src/commands/permitCliReads/runHelp.ts
20625
20625
  import { exec as exec2 } from "child_process";
20626
20626
  function runHelp(args) {
20627
- return new Promise((resolve30) => {
20627
+ return new Promise((resolve31) => {
20628
20628
  exec2(
20629
20629
  `${args.join(" ")} --help`,
20630
20630
  { encoding: "utf8", timeout: 3e4 },
20631
20631
  (_err, stdout, stderr) => {
20632
- resolve30(stdout || stderr || "");
20632
+ resolve31(stdout || stderr || "");
20633
20633
  }
20634
20634
  );
20635
20635
  });
@@ -21503,7 +21503,7 @@ function restoreIndex(paths, patch2) {
21503
21503
  }
21504
21504
  function pullKeepingIndex() {
21505
21505
  const paths = git2("diff --cached --name-only -z --no-renames").split("\0").filter(Boolean);
21506
- const patch2 = git2("diff --cached --binary --no-renames");
21506
+ const patch2 = git2("diff-index --cached -p --binary --no-renames HEAD");
21507
21507
  execSync26("git pull --autostash", { stdio: "inherit" });
21508
21508
  if (paths.length === 0 || findUnmergedPaths().length > 0) return;
21509
21509
  restoreIndex(paths, patch2);
@@ -27931,7 +27931,7 @@ function placedByDaemon() {
27931
27931
  function seed(worktreePath, clone) {
27932
27932
  console.log(`Preparing ${worktreePath}\u2026`);
27933
27933
  return new Promise(
27934
- (resolve30) => seedWorktree(worktreePath, clone, resolve30)
27934
+ (resolve31) => seedWorktree(worktreePath, clone, resolve31)
27935
27935
  );
27936
27936
  }
27937
27937
  async function moveToPrCheckoutTree() {
@@ -27966,7 +27966,7 @@ function prHeadBranch(number) {
27966
27966
  // src/commands/sessions/daemon/sendToDaemon.ts
27967
27967
  var WRITE_TIMEOUT_MS = 500;
27968
27968
  function sendToDaemon(message3) {
27969
- return new Promise((resolve30, reject) => {
27969
+ return new Promise((resolve31, reject) => {
27970
27970
  connectToDaemon().then((socket) => {
27971
27971
  const timer = setTimeout(() => {
27972
27972
  socket.destroy();
@@ -27980,7 +27980,7 @@ function sendToDaemon(message3) {
27980
27980
  `, () => {
27981
27981
  clearTimeout(timer);
27982
27982
  socket.end();
27983
- resolve30();
27983
+ resolve31();
27984
27984
  });
27985
27985
  }, reject);
27986
27986
  });
@@ -29148,25 +29148,25 @@ function isVisibleText(t) {
29148
29148
  return /[a-zA-Z]{3,}/.test(t);
29149
29149
  }
29150
29150
  var isHashtag = (t) => /^#[A-Za-z0-9_]+$/.test(t);
29151
- function collectRscText(v, resolve30, sink3, seen) {
29151
+ function collectRscText(v, resolve31, sink3, seen) {
29152
29152
  if (v == null) return;
29153
29153
  if (typeof v === "string") {
29154
29154
  if (isRscRef(v)) {
29155
29155
  if (!seen.has(v)) {
29156
29156
  seen.add(v);
29157
- collectRscText(resolve30(v), resolve30, sink3, seen);
29157
+ collectRscText(resolve31(v), resolve31, sink3, seen);
29158
29158
  }
29159
29159
  } else if (isHashtag(v)) sink3.hashtags.push(v);
29160
29160
  else if (isVisibleText(v)) sink3.text.push(v);
29161
29161
  return;
29162
29162
  }
29163
29163
  if (Array.isArray(v)) {
29164
- for (const x of v) collectRscText(x, resolve30, sink3, seen);
29164
+ for (const x of v) collectRscText(x, resolve31, sink3, seen);
29165
29165
  return;
29166
29166
  }
29167
29167
  if (typeof v === "object") {
29168
29168
  for (const val of Object.values(v)) {
29169
- collectRscText(val, resolve30, sink3, seen);
29169
+ collectRscText(val, resolve31, sink3, seen);
29170
29170
  }
29171
29171
  }
29172
29172
  }
@@ -29198,7 +29198,7 @@ function visitObjects(root2, fn) {
29198
29198
  }
29199
29199
  }
29200
29200
  }
29201
- function buildMentionMap(rows, resolve30) {
29201
+ function buildMentionMap(rows, resolve31) {
29202
29202
  const map = /* @__PURE__ */ new Map();
29203
29203
  visitObjects(rows, (o) => {
29204
29204
  const url = profileActionUrl(o);
@@ -29206,7 +29206,7 @@ function buildMentionMap(rows, resolve30) {
29206
29206
  const slug2 = slugFromProfileUrl(url);
29207
29207
  if (!slug2 || map.has(slug2)) return;
29208
29208
  const sink3 = { text: [], hashtags: [] };
29209
- collectRscText(o.children, resolve30, sink3, /* @__PURE__ */ new Set());
29209
+ collectRscText(o.children, resolve31, sink3, /* @__PURE__ */ new Set());
29210
29210
  const name = sink3.text.join(" ").replace(/\s+/g, " ").trim();
29211
29211
  map.set(slug2, name ? { slug: slug2, name, url } : { slug: slug2, url });
29212
29212
  });
@@ -29292,10 +29292,10 @@ function buildPost(raw, mentionMap, author) {
29292
29292
 
29293
29293
  // src/commands/netcap/walkPostRow.ts
29294
29294
  var isCommentary = (o) => asObject(o.viewTrackingSpecs)?.viewName === "feed-commentary";
29295
- function walkPostRow(v, resolve30, raw) {
29295
+ function walkPostRow(v, resolve31, raw) {
29296
29296
  if (v == null || typeof v !== "object") return;
29297
29297
  if (Array.isArray(v)) {
29298
- for (const x of v) walkPostRow(x, resolve30, raw);
29298
+ for (const x of v) walkPostRow(x, resolve31, raw);
29299
29299
  return;
29300
29300
  }
29301
29301
  const o = v;
@@ -29309,9 +29309,9 @@ function walkPostRow(v, resolve30, raw) {
29309
29309
  }
29310
29310
  if (isCommentary(o)) {
29311
29311
  const sink3 = { text: raw.text, hashtags: raw.hashtags };
29312
- collectRscText(o.children, resolve30, sink3, /* @__PURE__ */ new Set());
29312
+ collectRscText(o.children, resolve31, sink3, /* @__PURE__ */ new Set());
29313
29313
  }
29314
- for (const val of Object.values(o)) walkPostRow(val, resolve30, raw);
29314
+ for (const val of Object.values(o)) walkPostRow(val, resolve31, raw);
29315
29315
  }
29316
29316
 
29317
29317
  // src/commands/netcap/extractLinkedInPosts.ts
@@ -29325,8 +29325,8 @@ function findCommentaryRows(rows) {
29325
29325
  }
29326
29326
  function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
29327
29327
  const rows = parseRscRows(flight);
29328
- const resolve30 = makeRscResolver(rows);
29329
- const mentionMap = buildMentionMap(rows, resolve30);
29328
+ const resolve31 = makeRscResolver(rows);
29329
+ const mentionMap = buildMentionMap(rows, resolve31);
29330
29330
  const posts = [];
29331
29331
  for (const id of findCommentaryRows(rows)) {
29332
29332
  const raw = {
@@ -29336,7 +29336,7 @@ function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
29336
29336
  links: [],
29337
29337
  related: []
29338
29338
  };
29339
- walkPostRow(rows[id], resolve30, raw);
29339
+ walkPostRow(rows[id], resolve31, raw);
29340
29340
  const post2 = buildPost(raw, mentionMap, author);
29341
29341
  if (post2) posts.push(post2);
29342
29342
  }
@@ -33436,7 +33436,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES2) {
33436
33436
 
33437
33437
  // src/commands/refactor/check.ts
33438
33438
  function runScript(script, cwd) {
33439
- return new Promise((resolve30) => {
33439
+ return new Promise((resolve31) => {
33440
33440
  const child = spawn7("npm", ["run", script], {
33441
33441
  stdio: "pipe",
33442
33442
  shell: true,
@@ -33450,7 +33450,7 @@ function runScript(script, cwd) {
33450
33450
  output += data.toString();
33451
33451
  });
33452
33452
  child.on("close", (code) => {
33453
- resolve30({ script, code: code ?? 1, output });
33453
+ resolve31({ script, code: code ?? 1, output });
33454
33454
  });
33455
33455
  });
33456
33456
  }
@@ -38189,12 +38189,12 @@ function onCloseResult(ctx, code) {
38189
38189
  return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
38190
38190
  }
38191
38191
  function waitForChildExit(ctx) {
38192
- return new Promise((resolve30) => {
38192
+ return new Promise((resolve31) => {
38193
38193
  let settled = false;
38194
38194
  const settle = (result) => {
38195
38195
  if (settled) return;
38196
38196
  settled = true;
38197
- resolve30(result);
38197
+ resolve31(result);
38198
38198
  };
38199
38199
  ctx.child.on("error", (err) => settle(onErrorResult(ctx, err)));
38200
38200
  ctx.child.on("close", (code) => settle(onCloseResult(ctx, code)));
@@ -40067,11 +40067,11 @@ import { randomUUID as randomUUID21 } from "crypto";
40067
40067
  // src/commands/sessions/shared/sendShowPreview.ts
40068
40068
  async function sendShowPreview(request) {
40069
40069
  const socket = await connectToDaemon();
40070
- await new Promise((resolve30, reject) => {
40070
+ await new Promise((resolve31, reject) => {
40071
40071
  const finish2 = (error) => {
40072
40072
  socket.destroy();
40073
40073
  if (error) reject(error);
40074
- else resolve30();
40074
+ else resolve31();
40075
40075
  };
40076
40076
  readSocketLines(socket, (line) => {
40077
40077
  const reply2 = parseReply(line);
@@ -41336,9 +41336,9 @@ function createReadlineInterface() {
41336
41336
  });
41337
41337
  }
41338
41338
  function askQuestion(rl, question) {
41339
- return new Promise((resolve30) => {
41339
+ return new Promise((resolve31) => {
41340
41340
  rl.question(question, (answer) => {
41341
- resolve30(answer.trim());
41341
+ resolve31(answer.trim());
41342
41342
  });
41343
41343
  });
41344
41344
  }
@@ -42540,12 +42540,12 @@ function decideLap(end, interrupted) {
42540
42540
  import { spawn as spawn9 } from "child_process";
42541
42541
  var WATCH_LAP_ARGS = ["watch", "wait", "--pull", "--build"];
42542
42542
  function runWatchLap() {
42543
- return new Promise((resolve30, reject) => {
42543
+ return new Promise((resolve31, reject) => {
42544
42544
  const assistFromPath = spawn9("assist", WATCH_LAP_ARGS, {
42545
42545
  stdio: "inherit",
42546
42546
  shell: process.platform === "win32"
42547
42547
  });
42548
- assistFromPath.on("close", (code, signal) => resolve30({ code, signal }));
42548
+ assistFromPath.on("close", (code, signal) => resolve31({ code, signal }));
42549
42549
  assistFromPath.on("error", reject);
42550
42550
  });
42551
42551
  }
@@ -43069,7 +43069,7 @@ function readMovement(cwd) {
43069
43069
  var CONTROL_POLL_MS = 1e3;
43070
43070
  function pollForMovement(options2) {
43071
43071
  const { upstream, intervalMs, timeoutMs, timeout, cwd, control } = options2;
43072
- return new Promise((resolve30) => {
43072
+ return new Promise((resolve31) => {
43073
43073
  let settled = false;
43074
43074
  const finish2 = (outcome) => {
43075
43075
  if (settled) return;
@@ -43078,7 +43078,7 @@ function pollForMovement(options2) {
43078
43078
  clearInterval(controller);
43079
43079
  clearTimeout(deadline);
43080
43080
  process.off("SIGINT", onInterrupt);
43081
- resolve30(outcome);
43081
+ resolve31(outcome);
43082
43082
  };
43083
43083
  const onInterrupt = () => finish2({ kind: "interrupted" });
43084
43084
  const check2 = () => {
@@ -43225,7 +43225,7 @@ function extractCode(url, expectedState) {
43225
43225
  return code;
43226
43226
  }
43227
43227
  function waitForCallback(port, expectedState) {
43228
- return new Promise((resolve30, reject) => {
43228
+ return new Promise((resolve31, reject) => {
43229
43229
  const timeout = setTimeout(() => {
43230
43230
  server.close();
43231
43231
  reject(new Error("Authorization timed out after 120 seconds"));
@@ -43242,7 +43242,7 @@ function waitForCallback(port, expectedState) {
43242
43242
  const code = extractCode(url, expectedState);
43243
43243
  respondHtml(res, 200, "Authorization successful!");
43244
43244
  server.close();
43245
- resolve30(code);
43245
+ resolve31(code);
43246
43246
  } catch (error) {
43247
43247
  respondHtml(res, 400, error.message);
43248
43248
  server.close();
@@ -43968,10 +43968,10 @@ var STATUS_TIMEOUT_MS2 = 5e3;
43968
43968
  function queryDaemon(socket) {
43969
43969
  socket.write(`${JSON.stringify({ type: "ping" })}
43970
43970
  `);
43971
- return new Promise((resolve30) => {
43971
+ return new Promise((resolve31) => {
43972
43972
  const result = { sessions: [] };
43973
43973
  const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
43974
- const timer = setTimeout(() => resolve30(result), STATUS_TIMEOUT_MS2);
43974
+ const timer = setTimeout(() => resolve31(result), STATUS_TIMEOUT_MS2);
43975
43975
  const lines2 = createInterface8({ input: socket });
43976
43976
  lines2.on("error", () => {
43977
43977
  });
@@ -43979,7 +43979,7 @@ function queryDaemon(socket) {
43979
43979
  applyLine(result, pending, line);
43980
43980
  if (pending.size === 0) {
43981
43981
  clearTimeout(timer);
43982
- resolve30(result);
43982
+ resolve31(result);
43983
43983
  }
43984
43984
  });
43985
43985
  });
@@ -44079,11 +44079,11 @@ function clearPersistedSessionsOnDrain() {
44079
44079
 
44080
44080
  // src/commands/sessions/daemon/readDaemonMessage.ts
44081
44081
  function readDaemonMessage(lines2, timeoutMs, fallback, match) {
44082
- return new Promise((resolve30) => {
44082
+ return new Promise((resolve31) => {
44083
44083
  const finish2 = (value) => {
44084
44084
  clearTimeout(timer);
44085
44085
  lines2.off("line", onLine);
44086
- resolve30(value);
44086
+ resolve31(value);
44087
44087
  };
44088
44088
  const timer = setTimeout(() => finish2(fallback), timeoutMs);
44089
44089
  const onLine = (line) => {
@@ -44253,9 +44253,9 @@ var ActiveSelection = class {
44253
44253
  return [...this.byRepo.keys()].at(-1) === cwd;
44254
44254
  }
44255
44255
  // why: on daemon restart, reload persisted selections but drop any whose session was not restored
44256
- restore(isLive) {
44256
+ restore(isLive2) {
44257
44257
  for (const [cwd, sessionId] of Object.entries(loadActiveSelection()))
44258
- if (isLive(sessionId)) this.byRepo.set(cwd, sessionId);
44258
+ if (isLive2(sessionId)) this.byRepo.set(cwd, sessionId);
44259
44259
  }
44260
44260
  toJSON() {
44261
44261
  return Object.fromEntries(this.byRepo);
@@ -44413,6 +44413,26 @@ function broadcastSessions(sessions, clients, linkedSessions = [], active) {
44413
44413
  broadcast(peers, { type: "sessions", sessions: local, active: {} });
44414
44414
  }
44415
44415
 
44416
+ // src/commands/sessions/daemon/findServerParents.ts
44417
+ import { existsSync as existsSync86 } from "fs";
44418
+ import { join as join103, resolve as resolve29 } from "path";
44419
+ function isLive(session) {
44420
+ return !!session.pty && session.status !== "done" && session.status !== "error";
44421
+ }
44422
+ function isLiveAgent(session) {
44423
+ return isLive(session) && session.commandType !== "run";
44424
+ }
44425
+ function serverRunDirs(sessions, file) {
44426
+ return new Set(
44427
+ sessions.filter((s) => s.server && s.cwd && isLive(s)).map((s) => resolve29(s.cwd)).filter((dir) => existsSync86(join103(dir, file)))
44428
+ );
44429
+ }
44430
+ function findServerParents(sessions, file) {
44431
+ const all = [...sessions.values()];
44432
+ const dirs = serverRunDirs(all, file);
44433
+ return all.filter((s) => isLiveAgent(s) && s.cwd && dirs.has(resolve29(s.cwd)));
44434
+ }
44435
+
44416
44436
  // src/commands/sessions/daemon/lastWriteTimes.ts
44417
44437
  import { readFile as readFile9 } from "fs/promises";
44418
44438
 
@@ -44523,9 +44543,7 @@ function newest(candidates, key) {
44523
44543
  return candidates.filter((c) => c[key] !== void 0).sort((a, b) => (b[key] ?? 0) - (a[key] ?? 0))[0];
44524
44544
  }
44525
44545
  async function findLastWriter(sessions, target) {
44526
- const live = [...sessions.values()].filter(
44527
- (s) => s.pty && s.status !== "done" && s.commandType !== "run"
44528
- );
44546
+ const live = [...sessions].filter(isLiveAgent);
44529
44547
  const candidates = await Promise.all(
44530
44548
  live.map(async (session) => {
44531
44549
  const transcript = await resolveTranscriptPath(session);
@@ -44540,6 +44558,18 @@ async function findLastWriter(sessions, target) {
44540
44558
  return writer?.id;
44541
44559
  }
44542
44560
 
44561
+ // src/commands/sessions/daemon/findDocsSession.ts
44562
+ async function findDocsSession(sessions, target) {
44563
+ const parents = findServerParents(sessions, target.file);
44564
+ daemonLog(
44565
+ `server parents of ${target.file}: ${parents.map((s) => s.id).join(", ") || "none"}`
44566
+ );
44567
+ if (parents.length === 0) return findLastWriter(sessions.values(), target);
44568
+ if (parents.length === 1) return parents[0].id;
44569
+ const latest2 = [...parents].sort((a, b) => b.startedAt - a.startedAt)[0];
44570
+ return await findLastWriter(parents, target) ?? latest2.id;
44571
+ }
44572
+
44543
44573
  // src/commands/sessions/daemon/releaseViewer.ts
44544
44574
  function releaseViewer(sessions, viewerId) {
44545
44575
  let released = false;
@@ -44829,10 +44859,10 @@ var SessionIo = class {
44829
44859
  );
44830
44860
  }
44831
44861
  async typePromptToLastWriter(target, text18) {
44832
- const id = await findLastWriter(this.sessions, target);
44862
+ const id = await findDocsSession(this.sessions, target);
44833
44863
  if (!id)
44834
44864
  return {
44835
- refused: `No live Claude session has written ${target.file} or anything in ${target.within}`
44865
+ refused: `No live Claude session shares a directory with the server for ${target.file} or has written anything in ${target.within}`
44836
44866
  };
44837
44867
  const refused = this.typePrompt(id, text18);
44838
44868
  return refused ? { refused } : id;
@@ -44973,11 +45003,11 @@ function sessionBase(id, status2) {
44973
45003
  }
44974
45004
 
44975
45005
  // src/commands/sessions/daemon/spawnPty.ts
44976
- import { existsSync as existsSync88 } from "fs";
45006
+ import { existsSync as existsSync89 } from "fs";
44977
45007
  import * as pty from "node-pty";
44978
45008
 
44979
45009
  // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
44980
- import { chmodSync, existsSync as existsSync87, statSync as statSync15 } from "fs";
45010
+ import { chmodSync, existsSync as existsSync88, statSync as statSync15 } from "fs";
44981
45011
  import { createRequire as createRequire3 } from "module";
44982
45012
  import path106 from "path";
44983
45013
  var require4 = createRequire3(import.meta.url);
@@ -44992,7 +45022,7 @@ function ensureSpawnHelperExecutable() {
44992
45022
  `${process.platform}-${process.arch}`,
44993
45023
  "spawn-helper"
44994
45024
  );
44995
- if (!existsSync87(helper)) return;
45025
+ if (!existsSync88(helper)) return;
44996
45026
  const mode = statSync15(helper).mode;
44997
45027
  if ((mode & 73) === 0) chmodSync(helper, mode | 493);
44998
45028
  }
@@ -45048,7 +45078,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
45048
45078
  });
45049
45079
  }
45050
45080
  function refuseMissingCwd(cwd, sessionId) {
45051
- if (!cwd || existsSync88(cwd)) return;
45081
+ if (!cwd || existsSync89(cwd)) return;
45052
45082
  daemonLog(
45053
45083
  `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
45054
45084
  );
@@ -45218,7 +45248,7 @@ function createRunSession(id, { runName, runArgs, cwd, meta }) {
45218
45248
  }
45219
45249
 
45220
45250
  // src/commands/sessions/daemon/autoUpdate/autoUpdateControl.ts
45221
- import { existsSync as existsSync89, rmSync as rmSync11, writeFileSync as writeFileSync54 } from "fs";
45251
+ import { existsSync as existsSync90, rmSync as rmSync11, writeFileSync as writeFileSync54 } from "fs";
45222
45252
  var paused;
45223
45253
  var wake;
45224
45254
  function persist2(value) {
@@ -45230,7 +45260,7 @@ function persist2(value) {
45230
45260
  }
45231
45261
  var autoUpdateControl = {
45232
45262
  paused: () => {
45233
- paused ??= existsSync89(daemonPaths.autoUpdatePaused);
45263
+ paused ??= existsSync90(daemonPaths.autoUpdatePaused);
45234
45264
  return paused;
45235
45265
  },
45236
45266
  setPaused: (value) => {
@@ -45238,11 +45268,11 @@ var autoUpdateControl = {
45238
45268
  persist2(value);
45239
45269
  wake?.();
45240
45270
  },
45241
- sleep: (ms) => new Promise((resolve30) => {
45271
+ sleep: (ms) => new Promise((resolve31) => {
45242
45272
  const done2 = () => {
45243
45273
  clearTimeout(timer);
45244
45274
  if (wake === done2) wake = void 0;
45245
- resolve30();
45275
+ resolve31();
45246
45276
  };
45247
45277
  const timer = setTimeout(done2, ms);
45248
45278
  wake = done2;
@@ -45573,7 +45603,7 @@ function clearLapSignals(cwd) {
45573
45603
  }
45574
45604
  function runUpdateLap(cwd, onOutput) {
45575
45605
  clearLapSignals(cwd);
45576
- return new Promise((resolve30, reject) => {
45606
+ return new Promise((resolve31, reject) => {
45577
45607
  const { ASSIST_ACTIVITY_ID: _activity, ...env } = process.env;
45578
45608
  const child = spawn11(
45579
45609
  process.execPath,
@@ -45593,7 +45623,7 @@ function runUpdateLap(cwd, onOutput) {
45593
45623
  child.stderr.on("data", (chunk) => onOutput(chunk.toString()));
45594
45624
  child.on("close", (code, signal) => {
45595
45625
  process.off("exit", killWithDaemon);
45596
- resolve30({ code, signal });
45626
+ resolve31({ code, signal });
45597
45627
  });
45598
45628
  child.on("error", (error) => {
45599
45629
  process.off("exit", killWithDaemon);
@@ -45673,17 +45703,17 @@ function setStatus2(session, newStatus) {
45673
45703
  }
45674
45704
 
45675
45705
  // src/commands/sessions/daemon/worktree/reapWorktree.ts
45676
- import { existsSync as existsSync91 } from "fs";
45706
+ import { existsSync as existsSync92 } from "fs";
45677
45707
  import { basename as basename31 } from "path";
45678
45708
 
45679
45709
  // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
45680
- import { existsSync as existsSync90 } from "fs";
45681
- import { join as join106 } from "path";
45710
+ import { existsSync as existsSync91 } from "fs";
45711
+ import { join as join107 } from "path";
45682
45712
 
45683
45713
  // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
45684
45714
  import { statSync as statSync16 } from "fs";
45685
45715
  import { rm as rm3 } from "fs/promises";
45686
- import { join as join105 } from "path";
45716
+ import { join as join106 } from "path";
45687
45717
  async function deleteTreeDirectly(clone, worktreePath, why) {
45688
45718
  if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
45689
45719
  const refusal = "it is a clone of its own, not a linked worktree";
@@ -45711,7 +45741,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
45711
45741
  return { removed: true };
45712
45742
  }
45713
45743
  function holdsAGitDirectoryRatherThanALink(worktreePath) {
45714
- return statSync16(join105(worktreePath, ".git"), {
45744
+ return statSync16(join106(worktreePath, ".git"), {
45715
45745
  throwIfNoEntry: false
45716
45746
  })?.isDirectory() === true;
45717
45747
  }
@@ -45747,7 +45777,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
45747
45777
  );
45748
45778
  }
45749
45779
  function strandedReason(worktreePath, cause) {
45750
- if (!existsSync90(join106(worktreePath, ".git")))
45780
+ if (!existsSync91(join107(worktreePath, ".git")))
45751
45781
  return "its .git link is already gone";
45752
45782
  if (/not a working tree|not a git repository/i.test(reason2(cause)))
45753
45783
  return "git no longer recognises it as a working tree";
@@ -45799,7 +45829,7 @@ function reason3(error) {
45799
45829
 
45800
45830
  // src/commands/sessions/daemon/worktree/reapWorktree.ts
45801
45831
  async function reapWorktree(worktreePath, force = false) {
45802
- if (!existsSync91(worktreePath)) {
45832
+ if (!existsSync92(worktreePath)) {
45803
45833
  forgetWorktree(worktreePath);
45804
45834
  daemonLog(
45805
45835
  `worktree ${worktreePath} already gone; its record was forgotten`
@@ -45824,7 +45854,7 @@ async function reapWorktree(worktreePath, force = false) {
45824
45854
  }
45825
45855
  function owningClone(worktreePath) {
45826
45856
  const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
45827
- if (recorded && existsSync91(recorded)) return recorded;
45857
+ if (recorded && existsSync92(recorded)) return recorded;
45828
45858
  const detected = mainWorktree(worktreePath);
45829
45859
  if (detected) return detected;
45830
45860
  daemonLog(
@@ -45984,12 +46014,12 @@ function processCwd(link3) {
45984
46014
  var POLL_MS2 = 500;
45985
46015
  var GRACE_MS = 5e3;
45986
46016
  function awaitTreeVacated(session, treePath) {
45987
- return new Promise((resolve30) => {
46017
+ return new Promise((resolve31) => {
45988
46018
  let ticks = GRACE_MS / POLL_MS2;
45989
46019
  const settle = (outcome) => {
45990
46020
  clearTimeout(timer);
45991
46021
  session.closeGrace = void 0;
45992
- resolve30(outcome);
46022
+ resolve31(outcome);
45993
46023
  };
45994
46024
  const tick = () => {
45995
46025
  if (liveProcessesInTree(treePath).length === 0) settle("vacated");
@@ -46025,12 +46055,12 @@ async function closeBlockReason(sessionId, tree) {
46025
46055
  }
46026
46056
 
46027
46057
  // src/commands/sessions/daemon/worktree/watchGitState.ts
46028
- import { existsSync as existsSync92, watch } from "fs";
46058
+ import { existsSync as existsSync93, watch } from "fs";
46029
46059
  var DEBOUNCE_MS = 500;
46030
46060
  var POLL_MS3 = 3e4;
46031
46061
  function watchGitState(cwd, onChange) {
46032
46062
  const common = gitCommonDir(cwd);
46033
- if (!common || !existsSync92(common)) return void 0;
46063
+ if (!common || !existsSync93(common)) return void 0;
46034
46064
  const watchers = [
46035
46065
  watchGitDir(common, onChange),
46036
46066
  pollGitState(cwd, onChange)
@@ -46689,10 +46719,10 @@ function emitSessionOutput(session, clients, data) {
46689
46719
  }
46690
46720
 
46691
46721
  // src/commands/sessions/daemon/exitReason.ts
46692
- import { existsSync as existsSync93 } from "fs";
46693
- import { resolve as resolve29 } from "path";
46722
+ import { existsSync as existsSync94 } from "fs";
46723
+ import { resolve as resolve30 } from "path";
46694
46724
  function exitDetail(session) {
46695
- if (session.cwd && !existsSync93(session.cwd))
46725
+ if (session.cwd && !existsSync94(session.cwd))
46696
46726
  return `working directory ${session.cwd} no longer exists`;
46697
46727
  return missingRunConfigCwd(session);
46698
46728
  }
@@ -46705,8 +46735,8 @@ function missingRunConfigCwd(session) {
46705
46735
  const dir = session.cwd ?? process.cwd();
46706
46736
  const config = resolveRunConfig(session.runName, dir);
46707
46737
  if (!config?.cwd) return void 0;
46708
- const configured = resolve29(runConfigBaseDirFrom(dir), config.cwd);
46709
- if (existsSync93(configured)) return void 0;
46738
+ const configured = resolve30(runConfigBaseDirFrom(dir), config.cwd);
46739
+ if (existsSync94(configured)) return void 0;
46710
46740
  return `run config "${config.name}": cwd ${configured} does not exist`;
46711
46741
  }
46712
46742
 
@@ -46754,7 +46784,7 @@ function handleRefusedRun(session, exitCode, onStatusChange) {
46754
46784
  }
46755
46785
 
46756
46786
  // src/commands/sessions/daemon/watchActivity.ts
46757
- import { existsSync as existsSync94, mkdirSync as mkdirSync36, watch as watch2 } from "fs";
46787
+ import { existsSync as existsSync95, mkdirSync as mkdirSync36, watch as watch2 } from "fs";
46758
46788
  import { dirname as dirname44 } from "path";
46759
46789
 
46760
46790
  // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -46840,7 +46870,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
46840
46870
  if (timer) clearTimeout(timer);
46841
46871
  timer = setTimeout(read3, DEBOUNCE_MS2);
46842
46872
  });
46843
- if (existsSync94(path109)) read3();
46873
+ if (existsSync95(path109)) read3();
46844
46874
  }
46845
46875
  function refreshActivity(session) {
46846
46876
  if (session.commandType !== "assist" || !session.cwd) return;
@@ -48824,7 +48854,7 @@ function rearmStoppedSessions(sessions, notify2) {
48824
48854
  }
48825
48855
 
48826
48856
  // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
48827
- import { existsSync as existsSync96 } from "fs";
48857
+ import { existsSync as existsSync97 } from "fs";
48828
48858
  import { basename as basename33 } from "path";
48829
48859
 
48830
48860
  // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -48845,9 +48875,9 @@ function accountedTrees(sessions) {
48845
48875
  }
48846
48876
 
48847
48877
  // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
48848
- import { existsSync as existsSync95 } from "fs";
48878
+ import { existsSync as existsSync96 } from "fs";
48849
48879
  async function reclaimVanishedWorktrees(clone, paths) {
48850
- if (!existsSync95(clone)) {
48880
+ if (!existsSync96(clone)) {
48851
48881
  for (const { path: path109 } of paths) forgetWorktree(path109);
48852
48882
  daemonLog(
48853
48883
  `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -49013,7 +49043,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
49013
49043
  );
49014
49044
  continue;
49015
49045
  }
49016
- if (!existsSync96(path109)) {
49046
+ if (!existsSync97(path109)) {
49017
49047
  logVanishedTree(sessions, path109);
49018
49048
  vanished.set(clone, [
49019
49049
  ...vanished.get(clone) ?? [],
@@ -49441,7 +49471,7 @@ function failPendingCreators(state, message3) {
49441
49471
  }
49442
49472
  function resetRelayState(state, reason4) {
49443
49473
  failPendingCreators(state, reason4);
49444
- for (const resolve30 of state.historyWaiters) resolve30([]);
49474
+ for (const resolve31 of state.historyWaiters) resolve31([]);
49445
49475
  state.historyWaiters = [];
49446
49476
  state.sessions = [];
49447
49477
  state.lastSnapshot = void 0;
@@ -49833,16 +49863,16 @@ var HISTORY_TIMEOUT_MS = 5e3;
49833
49863
  function requestLinkHistory(ctx) {
49834
49864
  if (!ctx.greeted) return Promise.resolve([]);
49835
49865
  const waiters = ctx.relay.historyWaiters;
49836
- return new Promise((resolve30) => {
49866
+ return new Promise((resolve31) => {
49837
49867
  const settle = (sessions) => {
49838
49868
  clearTimeout(timer);
49839
- resolve30(sessions);
49869
+ resolve31(sessions);
49840
49870
  };
49841
49871
  const timer = setTimeout(() => {
49842
49872
  const index2 = waiters.indexOf(settle);
49843
49873
  if (index2 !== -1) waiters.splice(index2, 1);
49844
49874
  daemonLog(`link ${ctx.spec.name} ws: history timed out`);
49845
- resolve30(ctx.relay.lastHistory ?? []);
49875
+ resolve31(ctx.relay.lastHistory ?? []);
49846
49876
  }, HISTORY_TIMEOUT_MS);
49847
49877
  timer.unref?.();
49848
49878
  waiters.push(settle);
@@ -50089,7 +50119,7 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta, context) {
50089
50119
  }
50090
50120
 
50091
50121
  // src/commands/sessions/daemon/worktree/resumeInTree.ts
50092
- import { existsSync as existsSync99 } from "fs";
50122
+ import { existsSync as existsSync100 } from "fs";
50093
50123
 
50094
50124
  // src/commands/sessions/daemon/resumeSession.ts
50095
50125
  function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -50120,11 +50150,11 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
50120
50150
  }
50121
50151
 
50122
50152
  // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
50123
- import { existsSync as existsSync98 } from "fs";
50153
+ import { existsSync as existsSync99 } from "fs";
50124
50154
 
50125
50155
  // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
50126
- import { copyFileSync as copyFileSync4, existsSync as existsSync97, mkdirSync as mkdirSync38 } from "fs";
50127
- import { join as join107 } from "path";
50156
+ import { copyFileSync as copyFileSync4, existsSync as existsSync98, mkdirSync as mkdirSync38 } from "fs";
50157
+ import { join as join108 } from "path";
50128
50158
  function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
50129
50159
  const dir = projectDirForCwd(toCwd);
50130
50160
  if (dir === projectDirForCwd(fromCwd)) {
@@ -50133,8 +50163,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
50133
50163
  );
50134
50164
  return;
50135
50165
  }
50136
- const dest = join107(dir, `${claudeSessionId}.jsonl`);
50137
- if (existsSync97(dest)) {
50166
+ const dest = join108(dir, `${claudeSessionId}.jsonl`);
50167
+ if (existsSync98(dest)) {
50138
50168
  daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
50139
50169
  return;
50140
50170
  }
@@ -50185,7 +50215,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
50185
50215
  }
50186
50216
  function cloneForReapedTree(missingCwd) {
50187
50217
  const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
50188
- if (!clone || !existsSync98(clone))
50218
+ if (!clone || !existsSync99(clone))
50189
50219
  throw new Error(
50190
50220
  `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
50191
50221
  );
@@ -50194,7 +50224,7 @@ function cloneForReapedTree(missingCwd) {
50194
50224
 
50195
50225
  // src/commands/sessions/daemon/worktree/resumeInTree.ts
50196
50226
  function resumeInTree(ctx, sessionId, cwd, name, harness) {
50197
- if (!existsSync99(cwd))
50227
+ if (!existsSync100(cwd))
50198
50228
  return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
50199
50229
  const id = ctx.spawnWith(
50200
50230
  (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -50958,7 +50988,7 @@ var handleTypePromptToWriter = (client, m, d) => {
50958
50988
  sendTo(client, {
50959
50989
  type: "type-prompt-result",
50960
50990
  ok: typeof result === "string",
50961
- message: typeof result === "string" ? `Sent to assist session ${result}, the last to write ${target.file}` : result.refused
50991
+ message: typeof result === "string" ? `Sent to assist session ${result}` : result.refused
50962
50992
  });
50963
50993
  });
50964
50994
  };
@@ -51184,25 +51214,25 @@ var sessionSettingHandlers = {
51184
51214
 
51185
51215
  // src/commands/sessions/daemon/worktree/prCheckoutHolder.ts
51186
51216
  import { execFile as execFile14 } from "child_process";
51187
- import { existsSync as existsSync100 } from "fs";
51217
+ import { existsSync as existsSync101 } from "fs";
51188
51218
  function prHeadBranch2(number, cwd) {
51189
- return new Promise((resolve30) => {
51219
+ return new Promise((resolve31) => {
51190
51220
  execFile14(
51191
51221
  "gh",
51192
51222
  ["pr", "view", number, "--json", "headRefName", "-q", ".headRefName"],
51193
51223
  { cwd, encoding: "utf8", windowsHide: true },
51194
- (error, stdout) => resolve30(error ? null : stdout.trim() || null)
51224
+ (error, stdout) => resolve31(error ? null : stdout.trim() || null)
51195
51225
  );
51196
51226
  });
51197
51227
  }
51198
51228
  async function prCheckoutHolder(assistArgs, cwd) {
51199
51229
  const number = prCheckoutNumber(assistArgs);
51200
- if (!number || !cwd || !existsSync100(cwd)) return void 0;
51230
+ if (!number || !cwd || !existsSync101(cwd)) return void 0;
51201
51231
  const headRef = await prHeadBranch2(number, cwd);
51202
51232
  if (!headRef) return void 0;
51203
51233
  const listing = await gitOrNull(cwd, ["worktree", "list", "--porcelain"]);
51204
51234
  const holder = listing ? worktreeWithBranch(listing, headRef) : null;
51205
- if (!holder || !existsSync100(holder)) return void 0;
51235
+ if (!holder || !existsSync101(holder)) return void 0;
51206
51236
  daemonLog(
51207
51237
  `pr #${number} assist ${assistArgs[0]} launched in its checkout ${holder}: head branch ${headRef} is already checked out there, so no worktree is allocated`
51208
51238
  );