very-happy-cli 0.2.166 → 0.2.167

package/dist/{createSessionMetadata-DU0bCg2m.mjs → createSessionMetadata-BEZ4DIDA.mjs}

@@ -1,8 +1,58 @@
 import os from 'node:os';
-import { resolve } from 'node:path';
-import { c as configuration } from './configuration-D2v3puap.mjs';
+import { resolve, isAbsolute, dirname } from 'node:path';
+import { c as configuration } from './configuration-WspKd2C2.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { p as packageJson } from './package-BqwrPxL0.mjs';
+import { p as packageJson } from './package-DU1DxhH9.mjs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+
+const realFs = {
+  existsSync,
+  isDirectory: (path) => {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  readFileSync: (path) => readFileSync(path, "utf8")
+};
+function resolveSessionWorktree(cwd, fs = realFs) {
+  let dir = resolve(cwd);
+  for (let depth = 0; depth < 64; depth++) {
+    const dotGit = resolve(dir, ".git");
+    try {
+      if (fs.existsSync(dotGit)) {
+        if (fs.isDirectory(dotGit)) return null;
+        const gitdir = fs.readFileSync(dotGit).match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+        if (!gitdir) return null;
+        const absolute = isAbsolute(gitdir) ? gitdir : resolve(dir, gitdir);
+        if (!/[\\/]\.git[\\/]worktrees[\\/][^\\/]+[\\/]?$/.test(absolute)) return null;
+        let branch = null;
+        try {
+          const head = fs.readFileSync(resolve(absolute, "HEAD")).trim();
+          const ref = head.match(/^ref:\s*refs\/heads\/(.+)$/)?.[1];
+          branch = ref ?? null;
+        } catch {
+        }
+        return { branch, root: dir };
+      }
+    } catch {
+      return null;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function sessionWorktreeMetadata(cwd) {
+  try {
+    const worktree = resolveSessionWorktree(cwd);
+    return worktree ? { worktree } : {};
+  } catch {
+    return {};
+  }
+}
 
 const SPAWN_ORIGIN_TAG_MAX = 24;
 function spawnOriginTags(env = process.env, flavor = void 0) {
@@ -46,9 +96,11 @@ function createSessionMetadata(opts) {
     // B-091/B-303: dispatched sessions carry their spawn origin as a tag
     // from birth (see spawnOriginTags) — applies to every flavor the daemon
     // can spawn, since HAPPY_SPAWNED_BY is exported flavor-independently.
-    ...originTags ? { tags: originTags } : {}
+    ...originTags ? { tags: originTags } : {},
+    // B-586: linked git worktree → branch shown in the session list.
+    ...sessionWorktreeMetadata(process.cwd())
   };
   return { state, metadata };
 }
 
-export { createSessionMetadata as c, isValidSpawnOrigin as i, spawnOriginTags as s };
+export { sessionWorktreeMetadata as a, createSessionMetadata as c, isValidSpawnOrigin as i, spawnOriginTags as s };

package/dist/{createSessionMetadata-DbfRBhRu.cjs → createSessionMetadata-zQSz3hgk.cjs}

@@ -2,9 +2,59 @@
 
 var os = require('node:os');
 var path = require('node:path');
-var configuration = require('./configuration-B0cb3xA3.cjs');
+var configuration = require('./configuration-C3piBtxY.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var _package = require('./package-C1XvUQFy.cjs');
+var _package = require('./package-C9ZP9bpX.cjs');
+var node_fs = require('node:fs');
+
+const realFs = {
+  existsSync: node_fs.existsSync,
+  isDirectory: (path) => {
+    try {
+      return node_fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  readFileSync: (path) => node_fs.readFileSync(path, "utf8")
+};
+function resolveSessionWorktree(cwd, fs = realFs) {
+  let dir = path.resolve(cwd);
+  for (let depth = 0; depth < 64; depth++) {
+    const dotGit = path.resolve(dir, ".git");
+    try {
+      if (fs.existsSync(dotGit)) {
+        if (fs.isDirectory(dotGit)) return null;
+        const gitdir = fs.readFileSync(dotGit).match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+        if (!gitdir) return null;
+        const absolute = path.isAbsolute(gitdir) ? gitdir : path.resolve(dir, gitdir);
+        if (!/[\\/]\.git[\\/]worktrees[\\/][^\\/]+[\\/]?$/.test(absolute)) return null;
+        let branch = null;
+        try {
+          const head = fs.readFileSync(path.resolve(absolute, "HEAD")).trim();
+          const ref = head.match(/^ref:\s*refs\/heads\/(.+)$/)?.[1];
+          branch = ref ?? null;
+        } catch {
+        }
+        return { branch, root: dir };
+      }
+    } catch {
+      return null;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function sessionWorktreeMetadata(cwd) {
+  try {
+    const worktree = resolveSessionWorktree(cwd);
+    return worktree ? { worktree } : {};
+  } catch {
+    return {};
+  }
+}
 
 const SPAWN_ORIGIN_TAG_MAX = 24;
 function spawnOriginTags(env = process.env, flavor = void 0) {
@@ -48,11 +98,14 @@ function createSessionMetadata(opts) {
     // B-091/B-303: dispatched sessions carry their spawn origin as a tag
     // from birth (see spawnOriginTags) — applies to every flavor the daemon
     // can spawn, since HAPPY_SPAWNED_BY is exported flavor-independently.
-    ...originTags ? { tags: originTags } : {}
+    ...originTags ? { tags: originTags } : {},
+    // B-586: linked git worktree → branch shown in the session list.
+    ...sessionWorktreeMetadata(process.cwd())
   };
   return { state, metadata };
 }
 
 exports.createSessionMetadata = createSessionMetadata;
 exports.isValidSpawnOrigin = isValidSpawnOrigin;
+exports.sessionWorktreeMetadata = sessionWorktreeMetadata;
 exports.spawnOriginTags = spawnOriginTags;

package/dist/defaultPermissionMode-Cif_RHGb.mjs

@@ -0,0 +1,191 @@
+import { l as logger } from './logger-CbBv3q_b.mjs';
+import { e as evaluateWrapperIdle, j as HIBERNATION_UNSUPPORTED_BACKOFF_MS } from './persistence-ON0zpHfb.mjs';
+
+const PRESENCE_SETTLE_MS = 6e3;
+async function commitHibernation(deps) {
+  const log = deps.log ?? ((message) => logger.debug(message));
+  if (!deps.claimExit()) {
+    log("[hibernate] exit already claimed for another reason; not hibernating");
+    return false;
+  }
+  const { client } = deps;
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let frozen = false;
+  let stamped = false;
+  const waitOrExit = async (work, fallback) => {
+    let settled = false;
+    const watched = work.finally(() => {
+      settled = true;
+    });
+    const exitWatch = (async () => {
+      while (!settled && !deps.exitRequested()) await sleep(EXIT_POLL_MS);
+      return settled ? watched : fallback;
+    })();
+    return Promise.race([watched, exitWatch]);
+  };
+  const abort = async (why2) => {
+    log(`[hibernate] aborted at commit: ${why2}`);
+    if (stamped) {
+      const clear = (metadata) => {
+        const next = { ...metadata };
+        delete next.hibernation;
+        return next;
+      };
+      const cleared = await client.updateMetadataAndWait(clear, deps.exitRequested() ? EXIT_CLEAR_TIMEOUT_MS : void 0).catch(() => false);
+      if (!cleared) log("[hibernate] stamp clear not confirmed (it keeps retrying in the background)");
+    }
+    if (frozen) {
+      client.unmuteHeartbeats();
+      client.unfreezeInbound();
+    }
+    deps.releaseExit();
+    return false;
+  };
+  const moved = () => {
+    if (deps.exitRequested()) return "exit requested";
+    if (client.inboundRoutedSinceCommit()) return "inbound message";
+    const verdict = deps.recheck();
+    return verdict.ok ? null : verdict.reason;
+  };
+  client.beginHibernationCommit();
+  try {
+    await client.flush();
+  } catch (error) {
+    return abort(`flush failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let why = moved();
+  if (why) return abort(why);
+  client.freezeInbound();
+  client.muteHeartbeats();
+  frozen = true;
+  const stamp = { at: now(), seq: client.messageCursor, idleMs: deps.idleMs, v: 1 };
+  stamped = true;
+  const landed = await waitOrExit(client.updateMetadataAndWait((metadata) => ({ ...metadata, hibernation: stamp })).catch(() => false), false);
+  if (deps.exitRequested()) return abort("exit requested");
+  if (!landed) return abort("stamp not confirmed");
+  const settle = Math.max(0, client.lastHeartbeatAt + (deps.presenceSettleMs ?? PRESENCE_SETTLE_MS) - now());
+  if (settle > 0) await waitOrExit(sleep(settle), void 0);
+  why = moved();
+  if (why) return abort(why);
+  deps.markCommitted();
+  log(`[hibernate] committing: seq=${stamp.seq} idleMs=${stamp.idleMs}`);
+  await deps.finish(stamp);
+  return true;
+}
+const EXIT_POLL_MS = 100;
+const EXIT_CLEAR_TIMEOUT_MS = 1e3;
+class HibernationProbe {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  timer = null;
+  stopped = false;
+  running = false;
+  start() {
+    this.schedule(this.deps.checkMs);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== null) (this.deps.clearTimer ?? ((h) => clearTimeout(h)))(this.timer);
+    this.timer = null;
+  }
+  schedule(ms) {
+    if (this.stopped) return;
+    const set = this.deps.setTimer ?? ((fn, delay) => {
+      const handle = setTimeout(fn, delay);
+      handle.unref?.();
+      return handle;
+    });
+    this.timer = set(() => {
+      void this.tick();
+    }, Math.max(1e3, ms));
+  }
+  /** One sample; returns the delay it scheduled (or null when it hibernated / stopped). */
+  async tick() {
+    if (this.stopped || this.running) return null;
+    this.running = true;
+    const log = this.deps.log ?? ((message) => logger.debug(message));
+    try {
+      const now = (this.deps.now ?? Date.now)();
+      const snapshot = this.deps.snapshot();
+      const local = evaluateWrapperIdle(snapshot, 1, now);
+      if (!local.ok && local.reason !== "keep-awake") {
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      const answer = await this.deps.ask(snapshot);
+      if (answer === "unsupported") {
+        this.schedule(HIBERNATION_UNSUPPORTED_BACKOFF_MS);
+        return HIBERNATION_UNSUPPORTED_BACKOFF_MS;
+      }
+      if (answer === "error") {
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      if (answer.keepAwake === true) this.deps.onKeepAwakeLatched?.();
+      if (local.ok && answer.hibernate && typeof answer.idleMs === "number" && answer.idleMs > 0) {
+        const done = await this.deps.commit(answer.idleMs);
+        if (done) {
+          this.stopped = true;
+          return null;
+        }
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      const next = typeof answer.nextCheckMs === "number" && answer.nextCheckMs > 0 ? answer.nextCheckMs : this.deps.checkMs;
+      if (answer.reason) log(`[hibernate] daemon says stay awake (${answer.reason}); next check in ${Math.round(next / 1e3)}s`);
+      this.schedule(next);
+      return next;
+    } catch (error) {
+      log(`[hibernate] probe failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.schedule(this.deps.checkMs);
+      return this.deps.checkMs;
+    } finally {
+      this.running = false;
+    }
+  }
+}
+class HibernationExitLatch {
+  constructor(outranks) {
+    this.outranks = outranks;
+  }
+  active = false;
+  committed = false;
+  deferredIntent = null;
+  begin() {
+    if (this.active) return false;
+    this.active = true;
+    this.committed = false;
+    this.deferredIntent = null;
+    return true;
+  }
+  get hibernating() {
+    return this.active;
+  }
+  /** true = the caller must NOT run this exit now (deferred, or the process is already leaving). */
+  intercept(intent) {
+    if (!this.active) return false;
+    if (!this.committed && (this.deferredIntent === null || this.outranks(intent, this.deferredIntent))) this.deferredIntent = intent;
+    return true;
+  }
+  get exitRequested() {
+    return this.deferredIntent !== null;
+  }
+  commit() {
+    if (this.active) this.committed = true;
+  }
+  /** Abort: returns the deferred exit to run now (or null). No-op once committed. */
+  release() {
+    if (!this.active || this.committed) return null;
+    this.active = false;
+    const deferred = this.deferredIntent;
+    this.deferredIntent = null;
+    return deferred;
+  }
+}
+
+const DEFAULT_CLAUDE_PERMISSION_MODE = "default";
+const DEFAULT_CODEX_PERMISSION_MODE = "default";
+
+export { DEFAULT_CLAUDE_PERMISSION_MODE as D, HibernationProbe as H, HibernationExitLatch as a, DEFAULT_CODEX_PERMISSION_MODE as b, commitHibernation as c };

package/dist/defaultPermissionMode-DNKNzk7l.cjs

@@ -0,0 +1,197 @@
+'use strict';
+
+var logger = require('./logger-B_MWPbZz.cjs');
+var persistence = require('./persistence-BYGl0QYw.cjs');
+
+const PRESENCE_SETTLE_MS = 6e3;
+async function commitHibernation(deps) {
+  const log = deps.log ?? ((message) => logger.logger.debug(message));
+  if (!deps.claimExit()) {
+    log("[hibernate] exit already claimed for another reason; not hibernating");
+    return false;
+  }
+  const { client } = deps;
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let frozen = false;
+  let stamped = false;
+  const waitOrExit = async (work, fallback) => {
+    let settled = false;
+    const watched = work.finally(() => {
+      settled = true;
+    });
+    const exitWatch = (async () => {
+      while (!settled && !deps.exitRequested()) await sleep(EXIT_POLL_MS);
+      return settled ? watched : fallback;
+    })();
+    return Promise.race([watched, exitWatch]);
+  };
+  const abort = async (why2) => {
+    log(`[hibernate] aborted at commit: ${why2}`);
+    if (stamped) {
+      const clear = (metadata) => {
+        const next = { ...metadata };
+        delete next.hibernation;
+        return next;
+      };
+      const cleared = await client.updateMetadataAndWait(clear, deps.exitRequested() ? EXIT_CLEAR_TIMEOUT_MS : void 0).catch(() => false);
+      if (!cleared) log("[hibernate] stamp clear not confirmed (it keeps retrying in the background)");
+    }
+    if (frozen) {
+      client.unmuteHeartbeats();
+      client.unfreezeInbound();
+    }
+    deps.releaseExit();
+    return false;
+  };
+  const moved = () => {
+    if (deps.exitRequested()) return "exit requested";
+    if (client.inboundRoutedSinceCommit()) return "inbound message";
+    const verdict = deps.recheck();
+    return verdict.ok ? null : verdict.reason;
+  };
+  client.beginHibernationCommit();
+  try {
+    await client.flush();
+  } catch (error) {
+    return abort(`flush failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let why = moved();
+  if (why) return abort(why);
+  client.freezeInbound();
+  client.muteHeartbeats();
+  frozen = true;
+  const stamp = { at: now(), seq: client.messageCursor, idleMs: deps.idleMs, v: 1 };
+  stamped = true;
+  const landed = await waitOrExit(client.updateMetadataAndWait((metadata) => ({ ...metadata, hibernation: stamp })).catch(() => false), false);
+  if (deps.exitRequested()) return abort("exit requested");
+  if (!landed) return abort("stamp not confirmed");
+  const settle = Math.max(0, client.lastHeartbeatAt + (deps.presenceSettleMs ?? PRESENCE_SETTLE_MS) - now());
+  if (settle > 0) await waitOrExit(sleep(settle), void 0);
+  why = moved();
+  if (why) return abort(why);
+  deps.markCommitted();
+  log(`[hibernate] committing: seq=${stamp.seq} idleMs=${stamp.idleMs}`);
+  await deps.finish(stamp);
+  return true;
+}
+const EXIT_POLL_MS = 100;
+const EXIT_CLEAR_TIMEOUT_MS = 1e3;
+class HibernationProbe {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  timer = null;
+  stopped = false;
+  running = false;
+  start() {
+    this.schedule(this.deps.checkMs);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== null) (this.deps.clearTimer ?? ((h) => clearTimeout(h)))(this.timer);
+    this.timer = null;
+  }
+  schedule(ms) {
+    if (this.stopped) return;
+    const set = this.deps.setTimer ?? ((fn, delay) => {
+      const handle = setTimeout(fn, delay);
+      handle.unref?.();
+      return handle;
+    });
+    this.timer = set(() => {
+      void this.tick();
+    }, Math.max(1e3, ms));
+  }
+  /** One sample; returns the delay it scheduled (or null when it hibernated / stopped). */
+  async tick() {
+    if (this.stopped || this.running) return null;
+    this.running = true;
+    const log = this.deps.log ?? ((message) => logger.logger.debug(message));
+    try {
+      const now = (this.deps.now ?? Date.now)();
+      const snapshot = this.deps.snapshot();
+      const local = persistence.evaluateWrapperIdle(snapshot, 1, now);
+      if (!local.ok && local.reason !== "keep-awake") {
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      const answer = await this.deps.ask(snapshot);
+      if (answer === "unsupported") {
+        this.schedule(persistence.HIBERNATION_UNSUPPORTED_BACKOFF_MS);
+        return persistence.HIBERNATION_UNSUPPORTED_BACKOFF_MS;
+      }
+      if (answer === "error") {
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      if (answer.keepAwake === true) this.deps.onKeepAwakeLatched?.();
+      if (local.ok && answer.hibernate && typeof answer.idleMs === "number" && answer.idleMs > 0) {
+        const done = await this.deps.commit(answer.idleMs);
+        if (done) {
+          this.stopped = true;
+          return null;
+        }
+        this.schedule(this.deps.checkMs);
+        return this.deps.checkMs;
+      }
+      const next = typeof answer.nextCheckMs === "number" && answer.nextCheckMs > 0 ? answer.nextCheckMs : this.deps.checkMs;
+      if (answer.reason) log(`[hibernate] daemon says stay awake (${answer.reason}); next check in ${Math.round(next / 1e3)}s`);
+      this.schedule(next);
+      return next;
+    } catch (error) {
+      log(`[hibernate] probe failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.schedule(this.deps.checkMs);
+      return this.deps.checkMs;
+    } finally {
+      this.running = false;
+    }
+  }
+}
+class HibernationExitLatch {
+  constructor(outranks) {
+    this.outranks = outranks;
+  }
+  active = false;
+  committed = false;
+  deferredIntent = null;
+  begin() {
+    if (this.active) return false;
+    this.active = true;
+    this.committed = false;
+    this.deferredIntent = null;
+    return true;
+  }
+  get hibernating() {
+    return this.active;
+  }
+  /** true = the caller must NOT run this exit now (deferred, or the process is already leaving). */
+  intercept(intent) {
+    if (!this.active) return false;
+    if (!this.committed && (this.deferredIntent === null || this.outranks(intent, this.deferredIntent))) this.deferredIntent = intent;
+    return true;
+  }
+  get exitRequested() {
+    return this.deferredIntent !== null;
+  }
+  commit() {
+    if (this.active) this.committed = true;
+  }
+  /** Abort: returns the deferred exit to run now (or null). No-op once committed. */
+  release() {
+    if (!this.active || this.committed) return null;
+    this.active = false;
+    const deferred = this.deferredIntent;
+    this.deferredIntent = null;
+    return deferred;
+  }
+}
+
+const DEFAULT_CLAUDE_PERMISSION_MODE = "default";
+const DEFAULT_CODEX_PERMISSION_MODE = "default";
+
+exports.DEFAULT_CLAUDE_PERMISSION_MODE = DEFAULT_CLAUDE_PERMISSION_MODE;
+exports.DEFAULT_CODEX_PERMISSION_MODE = DEFAULT_CODEX_PERMISSION_MODE;
+exports.HibernationExitLatch = HibernationExitLatch;
+exports.HibernationProbe = HibernationProbe;
+exports.commitHibernation = commitHibernation;

package/dist/{deterministicJson-D-WPUrZb.mjs → deterministicJson-BMMifViN.mjs}

@@ -4,19 +4,19 @@ import { randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
 import { dirname } from 'node:path';
 import { z } from 'zod';
-import { T as TeamConnectionPreflightError, c as createTeamsClient } from './client-CbK33y_s.mjs';
-import { t as teamScopePath } from './context-DjfqLWzE.mjs';
-import { g as waitForSessionKey, e as sendUserMessage } from './sessionOps-BnaEaOKs.mjs';
+import { T as TeamConnectionPreflightError, c as createTeamsClient } from './client-Dsfy_SAb.mjs';
+import { t as teamScopePath } from './context-Cr6a3NTg.mjs';
+import { g as waitForSessionKey, e as sendUserMessage } from './sessionOps-DZRH4-hV.mjs';
 import { T as TEAM_SKILL } from './resources-BdFBQi8r.mjs';
-import { T as TEAM_TOOL_NAMES, r as registerTeamsTools } from './tools-3X2z3YDe.mjs';
-import { c as createSelfReportState, A as AUTOMATION_TOOL_NAMES, r as registerAutomationTools, a as registerReportProgressTool, n as normalizeAttention, b as normalizePhase, d as normalizeProgress, s as shouldAcceptSelfReport } from './reportProgressTool-DnAD8wOa.mjs';
-import { S as SESSION_PEER_TOOL_NAMES, r as registerSessionPeerTools, a as createSessionPeerToolExecutor } from './peerTools-CeCe-3lk.mjs';
+import { T as TEAM_TOOL_NAMES, r as registerTeamsTools } from './tools-D91mq5Ib.mjs';
+import { c as createSelfReportState, A as AUTOMATION_TOOL_NAMES, r as registerAutomationTools, a as registerReportProgressTool, n as normalizeAttention, b as normalizePhase, d as normalizeProgress, s as shouldAcceptSelfReport } from './reportProgressTool-BvB13EwC.mjs';
+import { S as SESSION_PEER_TOOL_NAMES, r as registerSessionPeerTools, a as createSessionPeerToolExecutor } from './peerTools-os2DVjA0.mjs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { l as logger } from './logger-BpQcwNnt.mjs';
+import { l as logger } from './logger-CbBv3q_b.mjs';
 import { C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, c as CLIPBOARD_MAX_BYTES } from './limits-DIo7rEBR.mjs';
-import { A as ASSISTANT_TOOL_NAMES, a as registerAssistantTools, c as checkDownloadTarget } from './downloadTarget-DjSwMHun.mjs';
+import { A as ASSISTANT_TOOL_NAMES, a as registerAssistantTools, c as checkDownloadTarget } from './downloadTarget-Cp48jrIP.mjs';
 import { P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, c as PREVIEW_DOWNLOAD_PARAM_DESCRIPTION } from './agentGuidance-BDYt2Qy2.mjs';
 import { c as checkPreviewPath } from './previewPath-CXN4Vag0.mjs';
 import { createHash } from 'crypto';

package/dist/{deterministicJson-Dp3TVyap.cjs → deterministicJson-C7O2ulKY.cjs}

@@ -6,19 +6,19 @@ var node_crypto = require('node:crypto');
 var node_fs = require('node:fs');
 var path = require('node:path');
 var z = require('zod');
-var client = require('./client-JISJx2f-.cjs');
-var context = require('./context-BFUpYT39.cjs');
-var sessionOps = require('./sessionOps-DOyy4gkY.cjs');
+var client = require('./client-BKnKRLSt.cjs');
+var context = require('./context-Jrq4-eCZ.cjs');
+var sessionOps = require('./sessionOps-DzbZI3Eq.cjs');
 var resources = require('./resources-JDPugcDq.cjs');
-var tools = require('./tools-IJ0TAcJs.cjs');
-var reportProgressTool = require('./reportProgressTool-B-Rcy0s3.cjs');
-var peerTools = require('./peerTools-DPvbcs8V.cjs');
+var tools = require('./tools-DJIANHSh.cjs');
+var reportProgressTool = require('./reportProgressTool-D4KB_4cP.cjs');
+var peerTools = require('./peerTools-Dkbu7gag.cjs');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-var logger = require('./logger-JTcJU-uL.cjs');
+var logger = require('./logger-B_MWPbZz.cjs');
 var limits = require('./limits-C-a7gr04.cjs');
-var downloadTarget = require('./downloadTarget-CiQqRIc-.cjs');
+var downloadTarget = require('./downloadTarget-CWTb2-EM.cjs');
 var agentGuidance = require('./agentGuidance-BtBx2xxE.cjs');
 var previewPath = require('./previewPath-B0rBdhy1.cjs');
 var crypto = require('crypto');

package/dist/{doctor-CkJmdPbi.cjs → doctor-BykBaMTr.cjs}

@@ -1,14 +1,14 @@
 'use strict';
 
 var chalk = require('chalk');
-var configuration = require('./configuration-B0cb3xA3.cjs');
-var persistence = require('./persistence-2Xp_o6x6.cjs');
-var controlClient = require('./controlClient-CmnHGcyl.cjs');
+var configuration = require('./configuration-C3piBtxY.cjs');
+var persistence = require('./persistence-BYGl0QYw.cjs');
+var controlClient = require('./controlClient-BI6Fw3fQ.cjs');
 var doctor$1 = require('./doctor-u46qYYKX.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var _package = require('./package-C1XvUQFy.cjs');
+var _package = require('./package-C9ZP9bpX.cjs');
 var doctorReadiness = require('./doctorReadiness-BCZGcN0a.cjs');
 var authRelay = require('./authRelay-BdYkC1Po.cjs');
 var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
@@ -312,8 +312,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-KVWj6nCl.cjs'); });
-    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./index-DEKIgZUo.cjs'); });
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-DeAWzhSe.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./index-PNMQPKhz.cjs'); });
     const homes = await resolveAgentHomesForCli();
     console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
     console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));

package/dist/{doctor-BlXXyQ1L.mjs → doctor-D1KKyPzB.mjs}

@@ -1,12 +1,12 @@
 import chalk from 'chalk';
-import { c as configuration } from './configuration-D2v3puap.mjs';
-import { readSettings, readCredentials, readDaemonState } from './persistence-B9LmhAE2.mjs';
-import { c as checkIfDaemonRunningAndCleanupStaleState } from './controlClient-BMUJfUeF.mjs';
+import { c as configuration } from './configuration-WspKd2C2.mjs';
+import { r as readSettings, g as readCredentials, d as readDaemonState } from './persistence-ON0zpHfb.mjs';
+import { a as checkIfDaemonRunningAndCleanupStaleState } from './controlClient-DTheOlvC.mjs';
 import { findAllHappyProcesses } from './doctor-BPkYWSuq.mjs';
 import { statSync, realpathSync, existsSync, readdirSync } from 'node:fs';
 import { isAbsolute, resolve, dirname, basename, delimiter, join } from 'node:path';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { p as packageJson } from './package-BqwrPxL0.mjs';
+import { p as packageJson } from './package-DU1DxhH9.mjs';
 import { s as shareableSettingsSummary, c as collectRuntimeReadiness, S as SUPPORTED_NODE_LABEL, r as resolveClaudeCredentialReadiness, a as toolProbeLabel, b as daemonReadiness, d as daemonEndpointsMatch } from './doctorReadiness-C208SMN9.mjs';
 import { c as credentialRelayProblem } from './authRelay-DSAvg1uv.mjs';
 import { d as deriveLocalCliUpdateSummary } from './cliUpdate-Y34VGe9Y.mjs';
@@ -310,8 +310,8 @@ ${typeLabels[type] || type}:`));
   }
   console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
   try {
-    const { resolveAgentHomesForCli } = await import('./agentHome-2IbIjKCa.mjs');
-    const { describeAgentHome } = await import('./index-DQplgo0W.mjs');
+    const { resolveAgentHomesForCli } = await import('./agentHome-Ct-VXFeG.mjs');
+    const { describeAgentHome } = await import('./index-D8m8Ripb.mjs');
     const homes = await resolveAgentHomesForCli();
     console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
     console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));