very-happy-cli 0.2.159 → 0.2.160

package/dist/sessionScanner-BOrGjMXL.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+var sync = require('./sync-DccIKZ5_.cjs');
+var types = require('./types-CRS-srZK.cjs');
+var path$1 = require('node:path');
+var promises = require('node:fs/promises');
+var logger = require('./logger-CS0mw3fa.cjs');
+var startFileWatcher = require('./startFileWatcher-B4VsLgjD.cjs');
+var path = require('./path-B7zW-WwE.cjs');
+
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  get promise() {
+    return this._promise;
+  }
+}
+
+const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
+async function createSessionScanner(opts) {
+  const projectDir = path.getProjectPath(opts.workingDirectory);
+  let finishedSessions = /* @__PURE__ */ new Set();
+  let pendingSessions = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  let watchers = /* @__PURE__ */ new Map();
+  let processedMessageKeys = /* @__PURE__ */ new Set();
+  let deadSessions = /* @__PURE__ */ new Set();
+  if (opts.sessionId) {
+    let messages = await readSessionLog(projectDir, opts.sessionId);
+    logger.logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
+    for (let m of messages) {
+      processedMessageKeys.add(messageKey(m));
+    }
+    currentSessionId = opts.sessionId;
+  }
+  const sync$1 = new sync.InvalidateSync(async () => {
+    let sessions = [];
+    for (let p of pendingSessions) {
+      if (!deadSessions.has(p)) {
+        sessions.push(p);
+      }
+    }
+    if (currentSessionId && !pendingSessions.has(currentSessionId) && !deadSessions.has(currentSessionId)) {
+      sessions.push(currentSessionId);
+    }
+    for (let [sessionId] of watchers) {
+      if (!sessions.includes(sessionId) && !deadSessions.has(sessionId)) {
+        sessions.push(sessionId);
+      }
+    }
+    for (let session of sessions) {
+      const sessionMessages = await readSessionLog(projectDir, session);
+      let skipped = 0;
+      let sent = 0;
+      for (let file of sessionMessages) {
+        let key = messageKey(file);
+        if (processedMessageKeys.has(key)) {
+          skipped++;
+          continue;
+        }
+        processedMessageKeys.add(key);
+        logger.logger.debug(`[SESSION_SCANNER] Sending new message: type=${file.type}, uuid=${file.type === "summary" ? file.leafUuid : file.uuid}`);
+        opts.onMessage(file);
+        sent++;
+      }
+      if (sessionMessages.length > 0) {
+        logger.logger.debug(`[SESSION_SCANNER] Session ${session}: found=${sessionMessages.length}, skipped=${skipped}, sent=${sent}`);
+      }
+    }
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    for (let p of sessions) {
+      if (!watchers.has(p) && !deadSessions.has(p)) {
+        logger.logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
+        watchers.set(p, startFileWatcher.startFileWatcher(
+          path$1.join(projectDir, `${p}.jsonl`),
+          () => {
+            sync$1.invalidate();
+          },
+          {
+            missingFileTimeoutMs: opts.missingFileTimeoutMs,
+            onGaveUp: () => {
+              logger.logger.debug(`[SESSION_SCANNER] Session ${p} transcript never appeared \u2014 dropping it`);
+              watchers.get(p)?.();
+              watchers.delete(p);
+              deadSessions.add(p);
+              pendingSessions.delete(p);
+            }
+          }
+        ));
+      }
+    }
+  });
+  await sync$1.invalidateAndAwait();
+  const intervalId = setInterval(() => {
+    sync$1.invalidate();
+  }, 3e3);
+  return {
+    cleanup: async () => {
+      clearInterval(intervalId);
+      for (let w of watchers.values()) {
+        w();
+      }
+      watchers.clear();
+      await sync$1.invalidateAndAwait();
+      sync$1.stop();
+    },
+    onNewSession: async (sessionId, options) => {
+      if (currentSessionId === sessionId) {
+        logger.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        return;
+      }
+      if (deadSessions.delete(sessionId)) {
+        logger.logger.debug(`[SESSION_SCANNER] Reviving previously-dropped session: ${sessionId}`);
+      }
+      if (finishedSessions.has(sessionId)) {
+        logger.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        return;
+      }
+      if (pendingSessions.has(sessionId)) {
+        logger.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        return;
+      }
+      if (options?.treatExistingAsProcessed) {
+        const existing = await readSessionLog(projectDir, sessionId);
+        logger.logger.debug(`[SESSION_SCANNER] Pre-marking ${existing.length} existing messages as processed for new session ${sessionId}`);
+        for (const m of existing) {
+          processedMessageKeys.add(messageKey(m));
+        }
+      }
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      logger.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
+      currentSessionId = sessionId;
+      sync$1.invalidate();
+    }
+  };
+}
+function messageKey(message) {
+  if (message.type === "user") {
+    return message.uuid;
+  } else if (message.type === "assistant") {
+    return message.uuid;
+  } else if (message.type === "summary") {
+    return "summary: " + message.leafUuid + ": " + message.summary;
+  } else if (message.type === "system") {
+    return message.uuid;
+  } else {
+    throw Error();
+  }
+}
+async function readSessionLog(projectDir, sessionId) {
+  const expectedSessionFile = path$1.join(projectDir, `${sessionId}.jsonl`);
+  logger.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+  let file;
+  try {
+    file = await promises.readFile(expectedSessionFile, "utf-8");
+  } catch (error) {
+    logger.logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    return [];
+  }
+  let lines = file.split("\n");
+  let messages = [];
+  for (let l of lines) {
+    try {
+      if (l.trim() === "") {
+        continue;
+      }
+      let message = JSON.parse(l);
+      if (message.type && INTERNAL_CLAUDE_EVENT_TYPES.has(message.type)) {
+        continue;
+      }
+      let parsed = types.RawJSONLinesSchema.safeParse(message);
+      if (!parsed.success) {
+        continue;
+      }
+      messages.push(parsed.data);
+    } catch (e) {
+      logger.logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
+      continue;
+    }
+  }
+  return messages;
+}
+
+exports.Future = Future;
+exports.createSessionScanner = createSessionScanner;

package/dist/sessionScanner-CX3onqXh.mjs

@@ -0,0 +1,206 @@
+import { I as InvalidateSync } from './sync-C8gyQFMc.mjs';
+import { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { s as startFileWatcher } from './startFileWatcher-DErVWZE4.mjs';
+import { g as getProjectPath } from './path-D2wdaNSk.mjs';
+
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  get promise() {
+    return this._promise;
+  }
+}
+
+const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
+async function createSessionScanner(opts) {
+  const projectDir = getProjectPath(opts.workingDirectory);
+  let finishedSessions = /* @__PURE__ */ new Set();
+  let pendingSessions = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  let watchers = /* @__PURE__ */ new Map();
+  let processedMessageKeys = /* @__PURE__ */ new Set();
+  let deadSessions = /* @__PURE__ */ new Set();
+  if (opts.sessionId) {
+    let messages = await readSessionLog(projectDir, opts.sessionId);
+    logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
+    for (let m of messages) {
+      processedMessageKeys.add(messageKey(m));
+    }
+    currentSessionId = opts.sessionId;
+  }
+  const sync = new InvalidateSync(async () => {
+    let sessions = [];
+    for (let p of pendingSessions) {
+      if (!deadSessions.has(p)) {
+        sessions.push(p);
+      }
+    }
+    if (currentSessionId && !pendingSessions.has(currentSessionId) && !deadSessions.has(currentSessionId)) {
+      sessions.push(currentSessionId);
+    }
+    for (let [sessionId] of watchers) {
+      if (!sessions.includes(sessionId) && !deadSessions.has(sessionId)) {
+        sessions.push(sessionId);
+      }
+    }
+    for (let session of sessions) {
+      const sessionMessages = await readSessionLog(projectDir, session);
+      let skipped = 0;
+      let sent = 0;
+      for (let file of sessionMessages) {
+        let key = messageKey(file);
+        if (processedMessageKeys.has(key)) {
+          skipped++;
+          continue;
+        }
+        processedMessageKeys.add(key);
+        logger.debug(`[SESSION_SCANNER] Sending new message: type=${file.type}, uuid=${file.type === "summary" ? file.leafUuid : file.uuid}`);
+        opts.onMessage(file);
+        sent++;
+      }
+      if (sessionMessages.length > 0) {
+        logger.debug(`[SESSION_SCANNER] Session ${session}: found=${sessionMessages.length}, skipped=${skipped}, sent=${sent}`);
+      }
+    }
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    for (let p of sessions) {
+      if (!watchers.has(p) && !deadSessions.has(p)) {
+        logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
+        watchers.set(p, startFileWatcher(
+          join(projectDir, `${p}.jsonl`),
+          () => {
+            sync.invalidate();
+          },
+          {
+            missingFileTimeoutMs: opts.missingFileTimeoutMs,
+            onGaveUp: () => {
+              logger.debug(`[SESSION_SCANNER] Session ${p} transcript never appeared \u2014 dropping it`);
+              watchers.get(p)?.();
+              watchers.delete(p);
+              deadSessions.add(p);
+              pendingSessions.delete(p);
+            }
+          }
+        ));
+      }
+    }
+  });
+  await sync.invalidateAndAwait();
+  const intervalId = setInterval(() => {
+    sync.invalidate();
+  }, 3e3);
+  return {
+    cleanup: async () => {
+      clearInterval(intervalId);
+      for (let w of watchers.values()) {
+        w();
+      }
+      watchers.clear();
+      await sync.invalidateAndAwait();
+      sync.stop();
+    },
+    onNewSession: async (sessionId, options) => {
+      if (currentSessionId === sessionId) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        return;
+      }
+      if (deadSessions.delete(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] Reviving previously-dropped session: ${sessionId}`);
+      }
+      if (finishedSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        return;
+      }
+      if (pendingSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        return;
+      }
+      if (options?.treatExistingAsProcessed) {
+        const existing = await readSessionLog(projectDir, sessionId);
+        logger.debug(`[SESSION_SCANNER] Pre-marking ${existing.length} existing messages as processed for new session ${sessionId}`);
+        for (const m of existing) {
+          processedMessageKeys.add(messageKey(m));
+        }
+      }
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
+      currentSessionId = sessionId;
+      sync.invalidate();
+    }
+  };
+}
+function messageKey(message) {
+  if (message.type === "user") {
+    return message.uuid;
+  } else if (message.type === "assistant") {
+    return message.uuid;
+  } else if (message.type === "summary") {
+    return "summary: " + message.leafUuid + ": " + message.summary;
+  } else if (message.type === "system") {
+    return message.uuid;
+  } else {
+    throw Error();
+  }
+}
+async function readSessionLog(projectDir, sessionId) {
+  const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
+  logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+  let file;
+  try {
+    file = await readFile(expectedSessionFile, "utf-8");
+  } catch (error) {
+    logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    return [];
+  }
+  let lines = file.split("\n");
+  let messages = [];
+  for (let l of lines) {
+    try {
+      if (l.trim() === "") {
+        continue;
+      }
+      let message = JSON.parse(l);
+      if (message.type && INTERNAL_CLAUDE_EVENT_TYPES.has(message.type)) {
+        continue;
+      }
+      let parsed = RawJSONLinesSchema.safeParse(message);
+      if (!parsed.success) {
+        continue;
+      }
+      messages.push(parsed.data);
+    } catch (e) {
+      logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
+      continue;
+    }
+  }
+  return messages;
+}
+
+export { Future as F, createSessionScanner as c };

package/dist/{sessions-CzIH2rGp.mjs → sessions-BEG_HTSi.mjs}

@@ -1,17 +1,26 @@
 import chalk from 'chalk';
-import { D as DEFAULT_RECENT_LIMIT, M as MAX_READ_LIMIT, l as listAccountSessions, f as fillForeignAccountRows, e as listRemoteSessions, g as listSessions, h as cliPeerSelf, i as listRemotePeers, j as listPeerSessions, s as sendPeerMessage, w as waitForTurnEnd, T as TurnWaitTimeoutError, k as readSessionTranscript, m as waitForRemoteTurnEnd, n as readRemoteTranscript, o as stopSession, p as resolvePermissionRequest, q as archiveSession, t as PEER_SCOPES } from './agentGuidance-KgvYuF3R.mjs';
-import { d as readPersistedSessions, i as isValidSessionId } from './limits-CjRj8IX5.mjs';
+import { D as DEFAULT_RECENT_LIMIT, M as MAX_READ_LIMIT, l as listAccountSessions, a as listSessions, w as waitForTurnEnd, T as TurnWaitTimeoutError, r as readSessionTranscript, b as stopSession, c as resolvePermissionRequest, d as archiveSession } from './sessionOps-SuHW8Dfe.mjs';
+import { i as isValidSessionId } from './ids-DU6sLx4C.mjs';
+import { c as cliPeerSelf, l as listPeerSessions, s as sendPeerMessage, P as PEER_SCOPES } from './peerTools-BTqw97Gb.mjs';
+import { readPersistedSessions } from './persistence-HGW_ZVs9.mjs';
 import { resolve } from 'node:path';
-import 'zod';
-import 'node:crypto';
-import 'node:fs/promises';
+import { f as fillForeignAccountRows, l as listRemoteSessions, a as listRemotePeers, w as waitForRemoteTurnEnd, r as readRemoteTranscript } from './remoteSessionClient-CYnXRynE.mjs';
+import 'axios';
+import './configuration-RfeNjFmd.mjs';
 import 'node:fs';
 import 'node:os';
-import 'axios';
-import 'socket.io-client';
-import '@paralleldrive/cuid2';
+import './package-BhaKlnxz.mjs';
+import 'node:fs/promises';
+import './authRelay-DSAvg1uv.mjs';
+import 'node:crypto';
 import 'tweetnacl';
+import './controlClient-BGbDcgWS.mjs';
+import './logger-6HYUEXNk.mjs';
 import 'node:util';
+import './time-D0XyHOid.mjs';
+import 'socket.io-client';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import 'zod';
 
 const MACHINE_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
 const ACTIONS = ["list", "read", "stop", "archive", "approve", "deny", "peers", "message"];

package/dist/{sessions-Bh1pyddi.cjs → sessions-D74aJbhL.cjs}

@@ -1,19 +1,28 @@
 'use strict';
 
 var chalk = require('chalk');
-var agentGuidance = require('./agentGuidance-BRDN1NoZ.cjs');
-var persistence = require('./limits-BH5CV5vR.cjs');
+var sessionOps = require('./sessionOps-Dn8z85h_.cjs');
+var ids = require('./ids-B6ZC0HGt.cjs');
+var peerTools = require('./peerTools-BvKtHXj8.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
 var path = require('node:path');
-require('zod');
-require('node:crypto');
-require('node:fs/promises');
+var remoteSessionClient = require('./remoteSessionClient-B0LraSB9.cjs');
+require('axios');
+require('./configuration-BSYpcPwE.cjs');
 require('node:fs');
 require('node:os');
-require('axios');
-require('socket.io-client');
-require('@paralleldrive/cuid2');
+require('./package-BwMrPwqH.cjs');
+require('node:fs/promises');
+require('./authRelay-BdYkC1Po.cjs');
+require('node:crypto');
 require('tweetnacl');
+require('./controlClient-Bcwv3D21.cjs');
+require('./logger-CS0mw3fa.cjs');
 require('node:util');
+require('./time-DCuTyook.cjs');
+require('socket.io-client');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('zod');
 
 const MACHINE_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
 const ACTIONS = ["list", "read", "stop", "archive", "approve", "deny", "peers", "message"];
@@ -58,7 +67,7 @@ function parseSessionsArgs(args) {
     } else if (arg === "--scope") {
       const value = args[++i];
       if (value === void 0) throw new Error("--scope requires a value");
-      if (!agentGuidance.PEER_SCOPES.includes(value)) throw new Error(`--scope must be one of ${agentGuidance.PEER_SCOPES.join(", ")}`);
+      if (!peerTools.PEER_SCOPES.includes(value)) throw new Error(`--scope must be one of ${peerTools.PEER_SCOPES.join(", ")}`);
       options.scope = value;
     } else if (arg === "--cwd") {
       const value = args[++i];
@@ -102,7 +111,7 @@ function parseSessionsArgs(args) {
   if (ACTIONS_NEEDING_ID.has(options.action)) {
     const id = positionals[0];
     if (id === void 0) throw new Error(`${options.action} requires a session id`);
-    if (!persistence.isValidSessionId(id)) throw new Error(`Invalid session id: ${id}`);
+    if (!ids.isValidSessionId(id)) throw new Error(`Invalid session id: ${id}`);
     options.sessionId = id;
   }
   if (options.action === "message") {
@@ -206,8 +215,8 @@ ${chalk.bold("Options:")}
                      \`spawn --spawned-by\`). With --all only decryptable rows
                      can match.
   --limit <n>        list: how many NOT-running / not-attention sessions to
-                     include (default ${agentGuidance.DEFAULT_RECENT_LIMIT}; running and attention rows are
-                     never cut). read: how many messages (default 20, max ${agentGuidance.MAX_READ_LIMIT}).
+                     include (default ${sessionOps.DEFAULT_RECENT_LIMIT}; running and attention rows are
+                     never cut). read: how many messages (default 20, max ${sessionOps.MAX_READ_LIMIT}).
   --full             read only: do not truncate entries (default caps each
                      line at 500 chars).
   --answer           read only: print just the agent's reply to the latest
@@ -309,13 +318,13 @@ async function handleSessionsCommand(args) {
   }
   try {
     if (options.action === "list" && options.all) {
-      const listed = await agentGuidance.listAccountSessions({ recentLimit: options.tag ? 150 : options.limit, includeArchived: options.includeArchived });
-      const fill = await agentGuidance.fillForeignAccountRows(listed);
+      const listed = await sessionOps.listAccountSessions({ recentLimit: options.tag ? 150 : options.limit, includeArchived: options.includeArchived });
+      const fill = await remoteSessionClient.fillForeignAccountRows(listed);
       let sessions = fill.rows;
       if (options.tag) {
         const wanted = options.tag;
         sessions = sessions.filter((summary) => summary.tags?.includes(wanted) === true);
-        const recentLimit = Math.max(0, options.limit ?? agentGuidance.DEFAULT_RECENT_LIMIT);
+        const recentLimit = Math.max(0, options.limit ?? sessionOps.DEFAULT_RECENT_LIMIT);
         let idleKept = 0;
         sessions = sessions.filter((summary) => summary.attention || summary.live || idleKept++ < recentLimit);
       }
@@ -339,7 +348,7 @@ async function handleSessionsCommand(args) {
       process.exit(0);
     }
     if (options.action === "list" && options.machine) {
-      const listing = await agentGuidance.listRemoteSessions(options.machine, { tag: options.tag, limit: options.limit });
+      const listing = await remoteSessionClient.listRemoteSessions(options.machine, { tag: options.tag, limit: options.limit });
       const sessions = listing.sessions;
       if (options.json) {
         console.log(JSON.stringify({ sessions, machine: { id: listing.machineId, host: listing.host } }));
@@ -352,7 +361,7 @@ async function handleSessionsCommand(args) {
       process.exit(0);
     }
     if (options.action === "list") {
-      const sessions = await agentGuidance.listSessions({ tag: options.tag, recentLimit: options.limit });
+      const sessions = await sessionOps.listSessions({ tag: options.tag, recentLimit: options.limit });
       if (options.json) {
         console.log(JSON.stringify({ sessions }));
       } else if (sessions.length === 0) {
@@ -365,9 +374,9 @@ async function handleSessionsCommand(args) {
     if (options.action === "peers" || options.action === "message") {
       const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
       const persisted = persistence.readPersistedSessions();
-      const context = { self: () => agentGuidance.cliPeerSelf(process.env, cwd, persisted), readPersisted: () => persisted };
+      const context = { self: () => peerTools.cliPeerSelf(process.env, cwd, persisted), readPersisted: () => persisted };
       if (options.action === "peers") {
-        const listing = options.machine ? await agentGuidance.listRemotePeers(options.machine, { ...options.scope ? { scope: options.scope } : {}, ...options.cwd ? { cwd: options.cwd } : {} }) : await agentGuidance.listPeerSessions(context, options.scope ?? "repo");
+        const listing = options.machine ? await remoteSessionClient.listRemotePeers(options.machine, { ...options.scope ? { scope: options.scope } : {}, ...options.cwd ? { cwd: options.cwd } : {} }) : await peerTools.listPeerSessions(context, options.scope ?? "repo");
         if (options.json) {
           console.log(JSON.stringify(listing));
         } else if (listing.peers.length === 0) {
@@ -388,7 +397,7 @@ async function handleSessionsCommand(args) {
       }
       const target = options.sessionId;
       try {
-        const result = await agentGuidance.sendPeerMessage(context, { to: target, body: options.text, replyTo: options.replyTo, ...options.machine ? { machineId: options.machine } : {} });
+        const result = await peerTools.sendPeerMessage(context, { to: target, body: options.text, replyTo: options.replyTo, ...options.machine ? { machineId: options.machine } : {} });
         if (options.json) console.log(JSON.stringify(result));
         else if (result.delivered) console.log(`Message ${result.messageId} delivered to ${target}${result.machine ? ` on ${result.machine.host}` : ""}
 ${result.url}`);
@@ -407,27 +416,27 @@ ${result.url}`);
       if (local) {
         if (options.wait) {
           try {
-            await agentGuidance.waitForTurnEnd(sessionId, { timeoutMs: (options.timeoutSec ?? 600) * 1e3 });
+            await sessionOps.waitForTurnEnd(sessionId, { timeoutMs: (options.timeoutSec ?? 600) * 1e3 });
           } catch (error) {
-            if (!(error instanceof agentGuidance.TurnWaitTimeoutError)) throw error;
+            if (!(error instanceof sessionOps.TurnWaitTimeoutError)) throw error;
             timedOut = true;
             console.error(chalk.yellow("Timeout:"), error.message);
           }
         }
-        result = await agentGuidance.readSessionTranscript(sessionId, options.limit ?? 20, { full: options.full });
+        result = await sessionOps.readSessionTranscript(sessionId, options.limit ?? 20, { full: options.full });
       } else {
         const readOptions = { limit: options.limit ?? 20, full: options.full, ...options.machine ? { machineId: options.machine } : {} };
         let remote;
         if (options.wait) {
           const timeoutMs = (options.timeoutSec ?? 600) * 1e3;
-          const waited = await agentGuidance.waitForRemoteTurnEnd(sessionId, { ...readOptions, timeoutMs });
+          const waited = await remoteSessionClient.waitForRemoteTurnEnd(sessionId, { ...readOptions, timeoutMs });
           remote = waited.read;
           if (waited.timedOut) {
             timedOut = true;
             console.error(chalk.yellow("Timeout:"), `Session ${sessionId} on ${remote.host}: the latest turn did not end within ${Math.round(timeoutMs / 1e3)}s`);
           }
         } else {
-          remote = await agentGuidance.readRemoteTranscript(sessionId, readOptions);
+          remote = await remoteSessionClient.readRemoteTranscript(sessionId, readOptions);
         }
         const { machineId, host, ...rest } = remote;
         result = { ...rest, machine: { id: machineId, host } };
@@ -447,7 +456,7 @@ ${result.url}`);
       process.exit(timedOut ? 2 : 0);
     }
     if (options.action === "stop") {
-      const stopped = await agentGuidance.stopSession(sessionId);
+      const stopped = await sessionOps.stopSession(sessionId);
       if (!stopped) {
         if (options.json) console.log(JSON.stringify({ sessionId, stopped: false }));
         console.error(chalk.red("Error:"), `Session ${sessionId} is not among the daemon's running sessions.`);
@@ -462,7 +471,7 @@ ${result.url}`);
       const verdict = options.action === "approve" ? { kind: "approve", forSession: options.forSession } : { kind: "deny", reason: options.reason };
       let result;
       try {
-        result = await agentGuidance.resolvePermissionRequest(sessionId, requestId, verdict, {
+        result = await sessionOps.resolvePermissionRequest(sessionId, requestId, verdict, {
           // T-014: a rate refusal waits (bounded) before re-sending;
           // say so on stderr so the wait does not look like a hang.
           onRateLimited: ({ attempt, waitMs, serverError }) => {
@@ -487,7 +496,7 @@ ${result.url}`);
       }
       process.exit(0);
     }
-    await agentGuidance.archiveSession(sessionId);
+    await sessionOps.archiveSession(sessionId);
     if (options.json) console.log(JSON.stringify({ sessionId, archived: true }));
     else console.log(`Archived ${sessionId}`);
     process.exit(0);