appduct 0.10.0 → 0.11.1

package/dist/cli/routes/daemon/run.js

@@ -0,0 +1,3246 @@
+// src/daemon/daemon.ts
+import { rm as rm5 } from "node:fs/promises";
+import {
+  MAX_TOOLS_FILTER_LENGTH,
+  RPC_METHODS,
+  isValidToolGroup,
+  summarizeToolGroups,
+  toolGroupMatches,
+  EVENT_KINDS
+} from "@appduct/shared";
+
+// src/package-version.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/package-root.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "appduct";
+var cached;
+var getPackageRoot = () => {
+  if (cached !== void 0) {
+    return cached;
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) {
+      let name;
+      try {
+        name = JSON.parse(readFileSync(candidate, "utf8")).name;
+      } catch {
+      }
+      if (name === PACKAGE_NAME) {
+        cached = dir;
+        return dir;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not locate the "${PACKAGE_NAME}" package root above ${import.meta.url}.`);
+    }
+    dir = parent;
+  }
+};
+
+// src/package-version.ts
+var DAEMON_VERSION_OVERRIDE_ENV = "APPDUCT_DAEMON_VERSION_OVERRIDE";
+var isTestRuntime = (env) => {
+  return Boolean(env.VITEST) || env.NODE_ENV === "test";
+};
+var cached2;
+var getPackageVersion = () => {
+  cached2 ??= JSON.parse(readFileSync2(join2(getPackageRoot(), "package.json"), "utf8")).version;
+  return cached2;
+};
+var getDaemonReportedVersion = (env = process.env) => {
+  if (!isTestRuntime(env)) {
+    return getPackageVersion();
+  }
+  const override = env[DAEMON_VERSION_OVERRIDE_ENV];
+  return override !== void 0 && override.length > 0 ? override : getPackageVersion();
+};
+
+// src/daemon/address.ts
+import { networkInterfaces } from "node:os";
+import {
+  isLinkLocalIpv6Address,
+  isPrivateIpv4Address,
+  isUniqueLocalIpv6Address
+} from "@appduct/shared";
+var isDockerDefaultBridgeAddress = (address) => {
+  return address.startsWith("172.17.");
+};
+var isCgnatIpv4Address = (address) => {
+  const parts = address.split(".");
+  if (parts.length !== 4) {
+    return false;
+  }
+  const first = Number(parts[0]);
+  const second = Number(parts[1]);
+  return first === 100 && Number.isInteger(second) && second >= 64 && second <= 127;
+};
+var isExcludedIpv4Address = (address) => {
+  return isDockerDefaultBridgeAddress(address) || isCgnatIpv4Address(address);
+};
+var detectAdvertisedAddress = (options = {}) => {
+  if (options.override) {
+    return {
+      family: options.override.includes(":") ? 6 : 4,
+      address: options.override
+    };
+  }
+  const ipv4Candidates = [];
+  const ipv6Candidates = [];
+  for (const entries of Object.values(networkInterfaces())) {
+    for (const entry of entries ?? []) {
+      if (entry.internal) {
+        continue;
+      }
+      if (entry.family === "IPv4") {
+        if (isExcludedIpv4Address(entry.address)) {
+          continue;
+        }
+        ipv4Candidates.push(entry.address);
+      } else if (entry.family === "IPv6") {
+        if (isLinkLocalIpv6Address(entry.address)) {
+          continue;
+        }
+        ipv6Candidates.push(entry.address);
+      }
+    }
+  }
+  const preferredIpv4 = ipv4Candidates.find((address) => isPrivateIpv4Address(address)) ?? ipv4Candidates[0];
+  if (preferredIpv4) {
+    return { family: 4, address: preferredIpv4 };
+  }
+  const preferredIpv6 = ipv6Candidates.find((address) => isUniqueLocalIpv6Address(address)) ?? ipv6Candidates[0];
+  if (preferredIpv6) {
+    return { family: 6, address: preferredIpv6 };
+  }
+  return { family: 4, address: "127.0.0.1" };
+};
+
+// src/daemon/audit.ts
+import { createHash } from "node:crypto";
+import { chmod, mkdir, open, readdir, rm, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// src/daemon/config.ts
+import { readFile } from "node:fs/promises";
+var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "wssPort",
+  "keyPath",
+  "graceSeconds",
+  "linkTtlSeconds",
+  "keepaliveIntervalSeconds",
+  "eventBufferSize",
+  "auditRetentionDays",
+  "daemonLogMaxBytes",
+  "policy",
+  "advertisedIp",
+  "scheme",
+  "restartDaemonOnVersionMismatch"
+]);
+var KNOWN_POLICY_KEYS = /* @__PURE__ */ new Set(["default", "destructive", "tools"]);
+var POLICY_DECISIONS = /* @__PURE__ */ new Set(["allow", "deny", "prompt"]);
+var DEFAULT_AUDIT_RETENTION_DAYS = 30;
+var DEFAULT_DAEMON_LOG_MAX_BYTES = 10 * 1024 * 1024;
+var AppductConfigError = class extends Error {
+  constructor(key, message) {
+    super(message);
+    this.key = key;
+    this.name = "AppductConfigError";
+  }
+};
+var configError = (key, message) => {
+  return new AppductConfigError(key, `Invalid Appduct config value for "${key}": ${message}`);
+};
+var requireWssPort = (value, key) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 65535) {
+    throw configError(key, "must be a port number between 0 and 65535 (0 binds an OS-assigned port).");
+  }
+  return value;
+};
+var requirePositiveInteger = (value, key) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw configError(key, "must be a positive integer.");
+  }
+  return value;
+};
+var requireNonEmptyString = (value, key) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw configError(key, "must be a non-empty string.");
+  }
+  return value;
+};
+var requireBoolean = (value, key) => {
+  if (typeof value !== "boolean") {
+    throw configError(key, "must be a boolean.");
+  }
+  return value;
+};
+var requirePolicyDecision = (value, key) => {
+  if (typeof value !== "string" || !POLICY_DECISIONS.has(value)) {
+    throw configError(key, 'must be "allow", "deny", or "prompt".');
+  }
+  return value;
+};
+var defaultConfig = (paths) => {
+  return {
+    wssPort: 8443,
+    keyPath: paths.keyPath,
+    graceSeconds: 600,
+    linkTtlSeconds: 300,
+    keepaliveIntervalSeconds: 15,
+    eventBufferSize: 256,
+    auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
+    daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+    restartDaemonOnVersionMismatch: false,
+    policy: {
+      default: "allow",
+      destructive: "allow"
+    }
+  };
+};
+var loadConfig = async (paths, options = {}) => {
+  const warn = options.warn ?? (() => {
+  });
+  const config = defaultConfig(paths);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(paths.configPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return config;
+    }
+    throw configError("config.json", `could not be read/parsed (${error.message}).`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw configError("config.json", "must be a JSON object.");
+  }
+  const parsed = raw;
+  for (const key of Object.keys(parsed)) {
+    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+      warn(`Unknown Appduct config key "${key}" is ignored.`);
+    }
+  }
+  if (parsed.wssPort !== void 0) {
+    config.wssPort = requireWssPort(parsed.wssPort, "wssPort");
+  }
+  if (parsed.keyPath !== void 0) {
+    config.keyPath = requireNonEmptyString(parsed.keyPath, "keyPath");
+  }
+  if (parsed.advertisedIp !== void 0) {
+    config.advertisedIp = requireNonEmptyString(parsed.advertisedIp, "advertisedIp");
+  }
+  if (parsed.scheme !== void 0) {
+    config.scheme = requireNonEmptyString(parsed.scheme, "scheme");
+  }
+  if (parsed.graceSeconds !== void 0) {
+    config.graceSeconds = requirePositiveInteger(parsed.graceSeconds, "graceSeconds");
+  }
+  if (parsed.linkTtlSeconds !== void 0) {
+    config.linkTtlSeconds = requirePositiveInteger(parsed.linkTtlSeconds, "linkTtlSeconds");
+  }
+  if (parsed.keepaliveIntervalSeconds !== void 0) {
+    config.keepaliveIntervalSeconds = requirePositiveInteger(
+      parsed.keepaliveIntervalSeconds,
+      "keepaliveIntervalSeconds"
+    );
+  }
+  if (parsed.eventBufferSize !== void 0) {
+    config.eventBufferSize = requirePositiveInteger(parsed.eventBufferSize, "eventBufferSize");
+  }
+  if (parsed.auditRetentionDays !== void 0) {
+    config.auditRetentionDays = requirePositiveInteger(parsed.auditRetentionDays, "auditRetentionDays");
+  }
+  if (parsed.daemonLogMaxBytes !== void 0) {
+    config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
+  }
+  if (parsed.restartDaemonOnVersionMismatch !== void 0) {
+    config.restartDaemonOnVersionMismatch = requireBoolean(
+      parsed.restartDaemonOnVersionMismatch,
+      "restartDaemonOnVersionMismatch"
+    );
+  }
+  if (parsed.policy !== void 0) {
+    if (typeof parsed.policy !== "object" || parsed.policy === null || Array.isArray(parsed.policy)) {
+      throw configError("policy", "must be an object.");
+    }
+    const policy = parsed.policy;
+    for (const key of Object.keys(policy)) {
+      if (!KNOWN_POLICY_KEYS.has(key)) {
+        warn(`Unknown Appduct config key "policy.${key}" is ignored.`);
+      }
+    }
+    if (policy.default !== void 0) {
+      config.policy.default = requirePolicyDecision(policy.default, "policy.default");
+    }
+    if (policy.destructive !== void 0) {
+      config.policy.destructive = requirePolicyDecision(policy.destructive, "policy.destructive");
+    }
+    if (policy.tools !== void 0) {
+      if (typeof policy.tools !== "object" || policy.tools === null || Array.isArray(policy.tools)) {
+        throw configError("policy.tools", "must be an object.");
+      }
+      const tools = {};
+      for (const [toolKey, toolValue] of Object.entries(policy.tools)) {
+        tools[toolKey] = requirePolicyDecision(toolValue, `policy.tools["${toolKey}"]`);
+      }
+      config.policy.tools = tools;
+    }
+  }
+  return config;
+};
+
+// src/daemon/audit.ts
+var canonicalize = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalize(record[key])]));
+  }
+  return value;
+};
+var canonicalArgsJson = (args) => {
+  return JSON.stringify(canonicalize(args));
+};
+var argsSha256 = (args) => {
+  return createHash("sha256").update(canonicalArgsJson(args)).digest("hex");
+};
+var dayStamp = (date) => {
+  return date.toISOString().slice(0, 10);
+};
+var AUDIT_DAY_FILE = /^(\d{4}-\d{2}-\d{2})\.jsonl$/u;
+var dayStampOfAuditFile = (name) => {
+  const match = AUDIT_DAY_FILE.exec(name);
+  if (!match) {
+    return void 0;
+  }
+  const stamp = match[1];
+  const parsed = /* @__PURE__ */ new Date(`${stamp}T00:00:00.000Z`);
+  return Number.isNaN(parsed.getTime()) || dayStamp(parsed) !== stamp ? void 0 : stamp;
+};
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var oldestRetainedStamp = (now, retentionDays) => {
+  const todayUtcMidnight = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+  const cutoff = new Date(todayUtcMidnight - retentionDays * MS_PER_DAY);
+  return Number.isNaN(cutoff.getTime()) ? "0000-00-00" : dayStamp(cutoff);
+};
+var auditFilePathForDate = (auditDir, date) => {
+  return join3(auditDir, `${dayStamp(date)}.jsonl`);
+};
+var appendLine = async (filePath, line) => {
+  const handle = await open(filePath, "a", 384);
+  try {
+    await handle.appendFile(line);
+    await chmod(filePath, 384);
+  } finally {
+    await handle.close();
+  }
+};
+var createAuditLogger = (options) => {
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const warn = options.warn ?? ((message) => {
+    process.stderr.write(`${message}
+`);
+  });
+  const retentionDays = options.retentionDays ?? DEFAULT_AUDIT_RETENTION_DAYS;
+  let failedWrites = 0;
+  let failedPrunes = 0;
+  let queue = Promise.resolve();
+  const listDayFiles = async () => {
+    let entries;
+    try {
+      entries = await readdir(options.auditDir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { files: [], failed: false };
+      }
+      return { files: [], failed: true, error };
+    }
+    const files = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+      const stamp = dayStampOfAuditFile(entry.name);
+      if (stamp !== void 0) {
+        files.push({ name: entry.name, stamp });
+      }
+    }
+    return { files, failed: false };
+  };
+  const pruneOnce = async () => {
+    const today = dayStamp(clock.now());
+    const cutoff = oldestRetainedStamp(clock.now(), retentionDays);
+    let deleted = 0;
+    let failed = 0;
+    const listing = await listDayFiles();
+    if (listing.failed) {
+      failedPrunes += 1;
+      warn(`appduct daemon: failed to read the audit directory to prune it: ${listing.error?.message}`);
+      return { deleted: 0, failed: 1 };
+    }
+    for (const file of listing.files) {
+      if (file.stamp === today || file.stamp >= cutoff) {
+        continue;
+      }
+      try {
+        await rm(join3(options.auditDir, file.name), { force: true });
+        deleted += 1;
+      } catch (error) {
+        failed += 1;
+        failedPrunes += 1;
+        warn(`appduct daemon: failed to prune the audit record "${file.name}": ${error.message}`);
+      }
+    }
+    return { deleted, failed };
+  };
+  const record = (entry) => {
+    const now = clock.now();
+    const full = { ts: now.toISOString(), ...entry };
+    const line = `${JSON.stringify(full)}
+`;
+    const filePath = auditFilePathForDate(options.auditDir, now);
+    queue = queue.then(async () => {
+      try {
+        await mkdir(options.auditDir, { recursive: true });
+        await appendLine(filePath, line);
+      } catch (error) {
+        failedWrites += 1;
+        warn(`appduct daemon: failed to write an audit record: ${error.message}`);
+      }
+    });
+  };
+  const prune = () => {
+    let settle;
+    const result = new Promise((resolve) => {
+      settle = resolve;
+    });
+    queue = queue.then(async () => {
+      try {
+        settle(await pruneOnce());
+      } catch (error) {
+        failedPrunes += 1;
+        warn(`appduct daemon: failed to prune the audit log: ${error.message}`);
+        settle({ deleted: 0, failed: 1 });
+      }
+    });
+    return result;
+  };
+  const stats = async () => {
+    const listing = await listDayFiles();
+    if (listing.failed) {
+      return {};
+    }
+    let files = 0;
+    let bytes = 0;
+    for (const file of listing.files) {
+      try {
+        bytes += (await stat(join3(options.auditDir, file.name))).size;
+        files += 1;
+      } catch {
+      }
+    }
+    return { files, bytes };
+  };
+  return {
+    record,
+    failedWrites: () => failedWrites,
+    failedPrunes: () => failedPrunes,
+    prune,
+    stats,
+    flush: () => queue
+  };
+};
+
+// src/daemon/calls.ts
+import { randomBytes } from "node:crypto";
+import {
+  clampToolTimeoutMs,
+  DEFAULT_TOOL_TIMEOUT_MS,
+  MAX_TOOL_TIMEOUT_MS,
+  MIN_TOOL_TIMEOUT_MS
+} from "@appduct/shared";
+
+// src/daemon/rpc-errors.ts
+var RpcApplicationError = class extends Error {
+  constructor(type, message, code = -32e3, details) {
+    super(message);
+    this.type = type;
+    this.code = code;
+    this.details = details;
+    this.name = "RpcApplicationError";
+  }
+};
+
+// src/daemon/timers.ts
+var systemTimers = {
+  setTimeout: (callback, ms) => setTimeout(callback, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  setInterval: (callback, ms) => setInterval(callback, ms),
+  clearInterval: (handle) => clearInterval(handle)
+};
+
+// src/daemon/calls.ts
+var DEFAULT_CALL_TIMEOUT_MS = DEFAULT_TOOL_TIMEOUT_MS;
+var generateCallId = () => `call_${randomBytes(16).toString("base64url")}`;
+var clampTimeout = (timeoutMs) => {
+  if (timeoutMs === void 0 || !Number.isFinite(timeoutMs)) {
+    return DEFAULT_CALL_TIMEOUT_MS;
+  }
+  return clampToolTimeoutMs(timeoutMs);
+};
+var TERMINATING_KIND_ERROR_TYPES = {
+  session_suspended: "session_suspended",
+  session_revoked: "unknown_session",
+  session_expired: "unknown_session"
+};
+var createCallsManager = (options) => {
+  const timers = options.timers ?? systemTimers;
+  const pendingBySession = /* @__PURE__ */ new Map();
+  const takePending = (sessionId, callId) => {
+    const sessionMap = pendingBySession.get(sessionId);
+    const pending = sessionMap?.get(callId);
+    if (!sessionMap || !pending) {
+      return void 0;
+    }
+    sessionMap.delete(callId);
+    if (sessionMap.size === 0) {
+      pendingBySession.delete(sessionId);
+    }
+    timers.clearTimeout(pending.timer);
+    return pending;
+  };
+  const call = (session, name, args, timeoutMs) => {
+    const callId = generateCallId();
+    const result = new Promise((resolve, reject) => {
+      const effectiveTimeoutMs = clampTimeout(timeoutMs);
+      const timer = timers.setTimeout(() => {
+        const pending = takePending(session.sessionId, callId);
+        pending?.reject(
+          new RpcApplicationError("tool_timeout", `Tool call "${name}" timed out after ${effectiveTimeoutMs}ms.`)
+        );
+      }, effectiveTimeoutMs);
+      let sessionMap = pendingBySession.get(session.sessionId);
+      if (!sessionMap) {
+        sessionMap = /* @__PURE__ */ new Map();
+        pendingBySession.set(session.sessionId, sessionMap);
+      }
+      sessionMap.set(callId, { alias: session.alias, resolve, reject, timer });
+      const message = {
+        type: "tool_call",
+        session_id: session.sessionId,
+        id: callId,
+        name,
+        args
+      };
+      const sent = options.send(session.sessionId, message);
+      if (!sent) {
+        const pending = takePending(session.sessionId, callId);
+        pending?.reject(new RpcApplicationError("session_not_active", "Session has no active socket."));
+      }
+    });
+    return { callId, result };
+  };
+  const handleToolResult = (message) => {
+    const pending = takePending(message.session_id, message.id);
+    pending?.resolve(message.result);
+  };
+  const handleToolError = (message) => {
+    const pending = takePending(message.session_id, message.id);
+    pending?.reject(new RpcApplicationError(message.error.type, message.error.message, -32e3, message.error.details));
+  };
+  const handleToolCallProgress = (message) => {
+    const sessionMap = pendingBySession.get(message.session_id);
+    const pending = sessionMap?.get(message.id);
+    if (!pending) {
+      return;
+    }
+    options.eventBus.emit({
+      // Its own EventKind (ARCHITECTURE.md §5), distinct from `tool_call_started`/
+      // `tool_call_finished` — subscribers correlate all three by `callId` in `data` without
+      // needing to sniff which kind carries a `progress`/`message` field.
+      kind: "tool_call_progress",
+      sessionId: message.session_id,
+      alias: pending.alias,
+      data: { callId: message.id, progress: message.progress, message: message.message }
+    });
+  };
+  const cancel = (sessionId, callId, reason) => {
+    const pending = pendingBySession.get(sessionId)?.get(callId);
+    if (!pending) {
+      return false;
+    }
+    const message = { type: "tool_cancel", session_id: sessionId, id: callId, reason };
+    return options.sendCancel(sessionId, message);
+  };
+  const rejectSession = (sessionId, errorType) => {
+    const sessionMap = pendingBySession.get(sessionId);
+    if (!sessionMap) {
+      return;
+    }
+    pendingBySession.delete(sessionId);
+    for (const pending of sessionMap.values()) {
+      timers.clearTimeout(pending.timer);
+      pending.reject(new RpcApplicationError(errorType, `Session transitioned while the call was pending.`));
+    }
+  };
+  const unsubscribeFromEventBus = options.eventBus.subscribe((event) => {
+    const errorType = TERMINATING_KIND_ERROR_TYPES[event.kind];
+    if (errorType && event.sessionId) {
+      rejectSession(event.sessionId, errorType);
+    }
+  });
+  const disposeAll = () => {
+    unsubscribeFromEventBus();
+    for (const sessionId of Array.from(pendingBySession.keys())) {
+      rejectSession(sessionId, "unknown_session");
+    }
+  };
+  return { call, handleToolResult, handleToolError, handleToolCallProgress, cancel, rejectSession, disposeAll };
+};
+
+// src/daemon/event-bus.ts
+var TERMINAL_EVENT_KINDS = /* @__PURE__ */ new Set(["session_expired", "session_revoked"]);
+var EXCLUDED_FROM_RETENTION = /* @__PURE__ */ new Set(["tool_call_progress"]);
+var createEventBus = (options = {}) => {
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const bufferSize = options.bufferSize ?? 256;
+  const listeners = /* @__PURE__ */ new Set();
+  const buffers = /* @__PURE__ */ new Map();
+  const cursors = /* @__PURE__ */ new Map();
+  const appendToBuffer = (sessionId, notification) => {
+    const buffer = buffers.get(sessionId) ?? [];
+    buffer.push(notification);
+    if (buffer.length > bufferSize) {
+      buffer.splice(0, buffer.length - bufferSize);
+    }
+    buffers.set(sessionId, buffer);
+  };
+  return {
+    emit: (event) => {
+      const sessionId = event.sessionId;
+      const seq = sessionId !== void 0 ? (cursors.get(sessionId) ?? 0) + 1 : 0;
+      if (sessionId !== void 0) {
+        cursors.set(sessionId, seq);
+      }
+      const notification = {
+        ...event,
+        ts: event.ts ?? clock.now().getTime(),
+        seq
+      };
+      if (sessionId !== void 0) {
+        if (TERMINAL_EVENT_KINDS.has(notification.kind)) {
+          buffers.delete(sessionId);
+          cursors.delete(sessionId);
+        } else if (!EXCLUDED_FROM_RETENTION.has(notification.kind)) {
+          appendToBuffer(sessionId, notification);
+        }
+      }
+      for (const listener of listeners) {
+        try {
+          listener(notification);
+        } catch {
+        }
+      }
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    since: (sessionId, query = {}) => {
+      const buffer = buffers.get(sessionId) ?? [];
+      const sessionCursor = cursors.get(sessionId) ?? 0;
+      let events = buffer.slice();
+      if (query.since !== void 0) {
+        events = events.filter((event) => event.seq > query.since);
+      }
+      if (query.kinds !== void 0) {
+        const kinds = new Set(query.kinds);
+        events = events.filter((event) => kinds.has(event.kind));
+      }
+      if (query.limit !== void 0 && events.length > query.limit) {
+        events = events.slice(0, query.limit);
+      }
+      const cursor = events.length > 0 ? events[events.length - 1].seq : sessionCursor;
+      return { events, cursor };
+    },
+    drop: (sessionId) => {
+      buffers.delete(sessionId);
+      cursors.delete(sessionId);
+    }
+  };
+};
+
+// src/daemon/listener.ts
+import { createServer as createHttpsServer } from "node:https";
+import { isSessionClaimMessage, isSessionResumeMessage, isSessionBoundMessage } from "@appduct/shared";
+import { WebSocketServer } from "ws";
+
+// src/daemon/sessions.ts
+import { randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import {
+  isEventMessage,
+  isToolCallProgressMessage,
+  isToolErrorMessage,
+  isToolRegistryDeltaMessage,
+  isToolRegistrySnapshotMessage,
+  isToolResultMessage,
+  parseSessionClaimDeviceFields
+} from "@appduct/shared";
+
+// src/daemon/links.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { encodeBootstrap } from "@appduct/shared";
+var SESSION_ID_BYTES = 12;
+var TOKEN_BYTES = 32;
+var generateSessionId = () => {
+  let candidate = randomBytes2(SESSION_ID_BYTES).toString("base64url");
+  while (candidate.startsWith("-")) {
+    candidate = randomBytes2(SESSION_ID_BYTES).toString("base64url");
+  }
+  return candidate;
+};
+var createPendingLinkRegistry = (options) => {
+  const records = /* @__PURE__ */ new Map();
+  const discard = (sessionId) => {
+    const record = records.get(sessionId);
+    if (!record) {
+      return;
+    }
+    options.timers.clearTimeout(record.timer);
+    records.delete(sessionId);
+    options.eventBus.drop(sessionId);
+  };
+  return {
+    create: (ttlSeconds, addressOverride) => {
+      const sessionId = generateSessionId();
+      const token = randomBytes2(TOKEN_BYTES);
+      const createdAt = options.clock.now();
+      const expiresAt = new Date(createdAt.getTime() + ttlSeconds * 1e3);
+      const detectedEndpoint = options.getEndpoint();
+      const endpoint = addressOverride ? {
+        family: addressOverride.includes(":") ? 6 : 4,
+        address: addressOverride,
+        port: detectedEndpoint.port
+      } : detectedEndpoint;
+      const timer = options.timers.setTimeout(() => {
+        options.eventBus.emit({ kind: "link_expired", sessionId, data: { reason: "link_ttl_expired" } });
+        const record = records.get(sessionId);
+        if (record) {
+          record.timer = options.timers.setTimeout(() => discard(sessionId), ttlSeconds * 1e3);
+        }
+      }, ttlSeconds * 1e3);
+      const link = { sessionId, token, createdAt, expiresAt };
+      records.set(sessionId, { link, attempts: 0, timer });
+      const deepLinkPayload = encodeBootstrap({
+        ...endpoint,
+        sessionId,
+        token: token.toString("base64url"),
+        expiresAt: Math.floor(expiresAt.getTime() / 1e3)
+      });
+      options.eventBus.emit({ kind: "link_created", sessionId, data: { expiresAt: link.expiresAt.toISOString() } });
+      return { link, deepLinkPayload, endpoint };
+    },
+    get: (sessionId) => records.get(sessionId)?.link,
+    consume: (sessionId) => {
+      const record = records.get(sessionId);
+      if (!record) {
+        return void 0;
+      }
+      options.timers.clearTimeout(record.timer);
+      records.delete(sessionId);
+      return record.link;
+    },
+    recordFailedAttempt: (sessionId) => {
+      const record = records.get(sessionId);
+      if (!record) {
+        return 0;
+      }
+      record.attempts += 1;
+      return record.attempts;
+    },
+    discard,
+    claimableCount: () => {
+      const now = options.clock.now().getTime();
+      let count = 0;
+      for (const record of records.values()) {
+        if (record.link.expiresAt.getTime() > now) {
+          count += 1;
+        }
+      }
+      return count;
+    },
+    disposeAll: () => {
+      for (const sessionId of Array.from(records.keys())) {
+        discard(sessionId);
+      }
+    }
+  };
+};
+
+// src/daemon/registry.ts
+var createToolRegistry = (onChange) => {
+  let tools = /* @__PURE__ */ new Map();
+  const notify = () => {
+    onChange?.();
+  };
+  return {
+    snapshot: (incoming) => {
+      tools = new Map(incoming.map((tool) => [tool.name, tool]));
+      notify();
+    },
+    upsert: (tool) => {
+      tools.set(tool.name, tool);
+      notify();
+    },
+    remove: (name) => {
+      if (tools.delete(name)) {
+        notify();
+      }
+    },
+    list: () => Array.from(tools.values()),
+    get: (name) => tools.get(name),
+    count: () => tools.size
+  };
+};
+
+// src/daemon/sessions.ts
+var RESUME_TOKEN_BYTES = 32;
+var POST_CLAIM_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "tool_registry_snapshot",
+  "tool_registry_delta",
+  "tool_result",
+  "tool_error",
+  "tool_call_progress",
+  "event"
+]);
+var isPostClaimMessageType = (type) => {
+  return typeof type === "string" && POST_CLAIM_MESSAGE_TYPES.has(type);
+};
+var slugifyDeviceModel = (model) => {
+  if (!model) {
+    return "device";
+  }
+  const slug = model.toLowerCase().replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/^-+|-+$/gu, "");
+  return slug.length > 0 ? slug : "device";
+};
+var dedupeAlias = (base, existingAliases) => {
+  if (!existingAliases.has(base)) {
+    return base;
+  }
+  let suffix = 2;
+  while (existingAliases.has(`${base}-${suffix}`)) {
+    suffix += 1;
+  }
+  return `${base}-${suffix}`;
+};
+var decodeFixedLengthToken = (base64url, expectedLength) => {
+  let decoded;
+  try {
+    decoded = Buffer.from(base64url, "base64url");
+  } catch {
+    return null;
+  }
+  return decoded.length === expectedLength ? decoded : null;
+};
+var tokensMatch = (candidate, expected) => {
+  if (!candidate || candidate.length !== expected.length) {
+    return false;
+  }
+  return timingSafeEqual(candidate, expected);
+};
+var MAX_FAILED_CLAIM_ATTEMPTS = 5;
+var closeSocket = (socket, code, reason) => {
+  try {
+    socket.close(code, reason);
+  } catch {
+    socket.terminate();
+  }
+};
+var createSessionManager = (options) => {
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const timers = options.timers ?? systemTimers;
+  const sessions = /* @__PURE__ */ new Map();
+  const pendingLinks = createPendingLinkRegistry({
+    getEndpoint: options.getEndpoint,
+    clock,
+    timers,
+    eventBus: options.eventBus
+  });
+  const emit = (kind, sessionId, alias, data) => {
+    options.eventBus.emit({ kind, sessionId, alias, data });
+  };
+  const toSummary = (session) => {
+    return {
+      sessionId: session.sessionId,
+      alias: session.alias,
+      state: session.state,
+      device: session.device,
+      createdAt: session.createdAt.toISOString(),
+      claimedAt: session.claimedAt.toISOString(),
+      ...session.suspendedAt ? { suspendedAt: session.suspendedAt.toISOString() } : {},
+      toolCount: session.registry.count()
+    };
+  };
+  const resolveSession = (selector) => {
+    const live = Array.from(sessions.values());
+    if (selector !== void 0) {
+      const match = live.find((session) => session.sessionId === selector || session.alias === selector);
+      if (!match) {
+        throw new RpcApplicationError("unknown_session", `No session matches "${selector}".`);
+      }
+      return match;
+    }
+    if (live.length === 0) {
+      throw new RpcApplicationError("no_session", "No active or suspended session, and none was specified.");
+    }
+    if (live.length > 1) {
+      throw new RpcApplicationError(
+        "ambiguous_session",
+        `Multiple sessions are live (${live.map((session) => session.alias).join(", ")}); specify a selector.`
+      );
+    }
+    return live[0];
+  };
+  const assignAlias = (model) => {
+    const base = slugifyDeviceModel(model);
+    const existing = new Set(Array.from(sessions.values(), (session) => session.alias));
+    return dedupeAlias(base, existing);
+  };
+  const sendAck = (socket, session) => {
+    const ack = {
+      type: "session_ack",
+      session_id: session.sessionId,
+      status: "ok",
+      alias: session.alias,
+      resume_token: session.resumeToken.toString("base64url"),
+      keepalive_interval_s: options.keepaliveIntervalSeconds,
+      grace_s: options.graceSeconds
+    };
+    socket.send(JSON.stringify(ack), (error) => {
+      if (error) {
+        closeSocket(socket, 1011, "send_failed");
+      }
+    });
+  };
+  const suspend = (sessionId) => {
+    const session = sessions.get(sessionId);
+    if (!session || session.state !== "active") {
+      return;
+    }
+    session.state = "suspended";
+    session.suspendedAt = clock.now();
+    session.socket = void 0;
+    session.missedPongs = 0;
+    session.graceTimer = timers.setTimeout(() => expire(sessionId), options.graceSeconds * 1e3);
+    emit("session_suspended", session.sessionId, session.alias, {});
+  };
+  const expire = (sessionId) => {
+    const session = sessions.get(sessionId);
+    if (!session || session.state !== "suspended") {
+      return;
+    }
+    sessions.delete(sessionId);
+    emit("session_expired", session.sessionId, session.alias, {});
+  };
+  const attachSocketHandlers = (session) => {
+    const socket = session.socket;
+    socket.on("error", () => {
+    });
+    socket.on("pong", () => {
+      session.missedPongs = 0;
+    });
+    socket.on("close", () => {
+      if (session.socket === socket) {
+        suspend(session.sessionId);
+      }
+    });
+  };
+  const keepaliveInterval = timers.setInterval(() => {
+    for (const session of sessions.values()) {
+      if (session.state !== "active" || !session.socket) {
+        continue;
+      }
+      if (session.missedPongs >= 2) {
+        const staleSocket = session.socket;
+        session.socket = void 0;
+        suspend(session.sessionId);
+        staleSocket.terminate();
+        continue;
+      }
+      session.missedPongs += 1;
+      try {
+        session.socket.ping();
+      } catch {
+      }
+    }
+  }, options.keepaliveIntervalSeconds * 1e3);
+  const createLink = (ttlSeconds, addressOverride) => {
+    const { link, deepLinkPayload, endpoint } = pendingLinks.create(
+      ttlSeconds ?? options.linkTtlSeconds,
+      addressOverride
+    );
+    return {
+      sessionId: link.sessionId,
+      deepLinkPayload,
+      endpoint,
+      expiresAt: Math.floor(link.expiresAt.getTime() / 1e3)
+    };
+  };
+  const handleClaim = (socket, message) => {
+    const pending = pendingLinks.get(message.session_id);
+    if (!pending) {
+      if (sessions.has(message.session_id)) {
+        closeSocket(socket, 1008, "already_claimed");
+      } else {
+        closeSocket(socket, 1008, "unknown_session");
+      }
+      return null;
+    }
+    const nowMs = clock.now().getTime();
+    if (pending.expiresAt.getTime() <= nowMs) {
+      pendingLinks.discard(pending.sessionId);
+      closeSocket(socket, 1008, "link_expired");
+      return null;
+    }
+    const candidateToken = decodeFixedLengthToken(message.token, pending.token.length);
+    if (!tokensMatch(candidateToken, pending.token)) {
+      const attempts = pendingLinks.recordFailedAttempt(pending.sessionId);
+      if (attempts >= MAX_FAILED_CLAIM_ATTEMPTS) {
+        pendingLinks.discard(pending.sessionId);
+        closeSocket(socket, 1008, "claim_attempts_exceeded");
+      } else {
+        closeSocket(socket, 1008, "invalid_token");
+      }
+      return null;
+    }
+    pendingLinks.consume(pending.sessionId);
+    const deviceFields = parseSessionClaimDeviceFields(message);
+    const device = deviceFields && deviceFields !== "invalid" ? deviceFields : {};
+    const alias = assignAlias(device.model);
+    const sessionId = pending.sessionId;
+    const session = {
+      sessionId,
+      alias,
+      state: "active",
+      device,
+      createdAt: pending.createdAt,
+      claimedAt: clock.now(),
+      resumeToken: randomBytes3(RESUME_TOKEN_BYTES),
+      socket,
+      missedPongs: 0,
+      registry: createToolRegistry(() => {
+        emit("tools_changed", sessionId, alias, { toolCount: session.registry.count() });
+      })
+    };
+    sessions.set(sessionId, session);
+    attachSocketHandlers(session);
+    sendAck(socket, session);
+    emit("session_claimed", sessionId, alias, { device });
+    return sessionId;
+  };
+  const handleResume = (socket, message) => {
+    const session = sessions.get(message.session_id);
+    if (!session) {
+      closeSocket(socket, 1008, "unknown_session");
+      return null;
+    }
+    const candidateToken = decodeFixedLengthToken(message.resume_token, session.resumeToken.length);
+    if (!tokensMatch(candidateToken, session.resumeToken)) {
+      closeSocket(socket, 1008, "invalid_resume_token");
+      return null;
+    }
+    if (session.state === "active" && session.socket && session.socket !== socket) {
+      const staleSocket = session.socket;
+      session.socket = void 0;
+      closeSocket(staleSocket, 1e3, "session_replaced");
+    }
+    if (session.graceTimer) {
+      timers.clearTimeout(session.graceTimer);
+      session.graceTimer = void 0;
+    }
+    session.resumeToken = randomBytes3(RESUME_TOKEN_BYTES);
+    session.state = "active";
+    session.suspendedAt = void 0;
+    session.socket = socket;
+    session.missedPongs = 0;
+    attachSocketHandlers(session);
+    sendAck(socket, session);
+    emit("session_resumed", session.sessionId, session.alias, {});
+    return session.sessionId;
+  };
+  const handlePostClaimMessage = (sessionId, socket, message) => {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      closeSocket(socket, 1008, "unknown_session");
+      return;
+    }
+    switch (message.type) {
+      case "tool_registry_snapshot": {
+        if (!isToolRegistrySnapshotMessage(message)) {
+          closeSocket(socket, 1008, "invalid_registry");
+          return;
+        }
+        session.registry.snapshot(message.tools);
+        return;
+      }
+      case "tool_registry_delta": {
+        if (!isToolRegistryDeltaMessage(message)) {
+          closeSocket(socket, 1008, "invalid_registry");
+          return;
+        }
+        if (message.operation === "upsert") {
+          session.registry.upsert(message.tool);
+        } else {
+          session.registry.remove(message.name);
+        }
+        return;
+      }
+      case "tool_result": {
+        if (!isToolResultMessage(message)) {
+          closeSocket(socket, 1008, "invalid_message");
+          return;
+        }
+        options.onToolFrame?.(message);
+        return;
+      }
+      case "tool_error": {
+        if (!isToolErrorMessage(message)) {
+          closeSocket(socket, 1008, "invalid_message");
+          return;
+        }
+        options.onToolFrame?.(message);
+        return;
+      }
+      case "tool_call_progress": {
+        if (!isToolCallProgressMessage(message)) {
+          closeSocket(socket, 1008, "invalid_message");
+          return;
+        }
+        options.onToolFrame?.(message);
+        return;
+      }
+      case "event": {
+        if (!isEventMessage(message)) {
+          closeSocket(socket, 1008, "invalid_message");
+          return;
+        }
+        options.onAppEvent?.(sessionId, session.alias, message);
+        return;
+      }
+      default:
+        closeSocket(socket, 1008, "unknown_message_type");
+    }
+  };
+  const revoke = (selector) => {
+    if (selector !== void 0 && !sessions.has(selector) && pendingLinks.get(selector)) {
+      pendingLinks.discard(selector);
+      emit("session_revoked", selector, void 0, {});
+      return;
+    }
+    const session = resolveSession(selector);
+    if (session.graceTimer) {
+      timers.clearTimeout(session.graceTimer);
+    }
+    if (session.socket) {
+      closeSocket(session.socket, 1e3, "revoked");
+    }
+    sessions.delete(session.sessionId);
+    emit("session_revoked", session.sessionId, session.alias, {});
+  };
+  const disposeAll = (code, reason) => {
+    timers.clearInterval(keepaliveInterval);
+    pendingLinks.disposeAll();
+    for (const session of sessions.values()) {
+      if (session.graceTimer) {
+        timers.clearTimeout(session.graceTimer);
+      }
+      if (session.socket) {
+        closeSocket(session.socket, code, reason);
+      }
+    }
+    sessions.clear();
+  };
+  const resolveForTools = (selector) => {
+    const session = resolveSession(selector);
+    return { sessionId: session.sessionId, alias: session.alias, state: session.state, registry: session.registry };
+  };
+  const sendToApp = (sessionId, message) => {
+    const session = sessions.get(sessionId);
+    if (!session || session.state !== "active" || !session.socket) {
+      return false;
+    }
+    const socket = session.socket;
+    socket.send(JSON.stringify(message), (error) => {
+      if (error) {
+        closeSocket(socket, 1011, "send_failed");
+      }
+    });
+    return true;
+  };
+  return {
+    createLink,
+    handleClaim,
+    handleResume,
+    handlePostClaimMessage,
+    list: () => Array.from(sessions.values(), toSummary),
+    pendingLinkCount: () => pendingLinks.claimableCount(),
+    describe: (selector) => toSummary(resolveSession(selector)),
+    revoke,
+    resolveForTools,
+    sendToolCall: sendToApp,
+    sendToolCancel: sendToApp,
+    disposeAll
+  };
+};
+
+// src/daemon/listener.ts
+var DEFAULT_PRE_CLAIM_TIMEOUT_MS = 1e4;
+var MAX_PAYLOAD_BYTES = 256 * 1024;
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var startListener = async (options) => {
+  const timers = options.timers ?? systemTimers;
+  const preClaimTimeoutMs = options.preClaimTimeoutMs ?? DEFAULT_PRE_CLAIM_TIMEOUT_MS;
+  const material = options.tls.current();
+  const httpsServer = createHttpsServer({ key: material.keyPem, cert: material.certPem });
+  httpsServer.on("error", () => {
+  });
+  const wss = new WebSocketServer({ server: httpsServer, maxPayload: MAX_PAYLOAD_BYTES });
+  wss.on("error", () => {
+  });
+  wss.on("connection", (socket) => {
+    socket.on("error", () => {
+    });
+    let claimedSessionId = null;
+    const preClaimTimer = timers.setTimeout(() => {
+      if (!claimedSessionId) {
+        socket.close(1008, "pre_claim_timeout");
+      }
+    }, preClaimTimeoutMs);
+    socket.once("close", () => {
+      timers.clearTimeout(preClaimTimer);
+    });
+    socket.on("message", (data, isBinary) => {
+      if (isBinary) {
+        socket.close(1003, "binary_frame_not_supported");
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(data.toString("utf8"));
+      } catch {
+        socket.close(1008, "invalid_json");
+        return;
+      }
+      if (!isRecord(parsed)) {
+        socket.close(1008, "invalid_json");
+        return;
+      }
+      if (claimedSessionId === null) {
+        if (isSessionClaimMessage(parsed)) {
+          const result = options.sessionManager.handleClaim(socket, parsed);
+          if (result) {
+            claimedSessionId = result;
+            timers.clearTimeout(preClaimTimer);
+          }
+          return;
+        }
+        if (isSessionResumeMessage(parsed)) {
+          const result = options.sessionManager.handleResume(socket, parsed);
+          if (result) {
+            claimedSessionId = result;
+            timers.clearTimeout(preClaimTimer);
+          }
+          return;
+        }
+        socket.close(1008, "expected_claim_or_resume");
+        return;
+      }
+      if (!isPostClaimMessageType(parsed.type)) {
+        socket.close(1008, "unknown_message_type");
+        return;
+      }
+      if (!isSessionBoundMessage(parsed) || parsed.session_id !== claimedSessionId) {
+        socket.close(1008, "session_mismatch");
+        return;
+      }
+      options.sessionManager.handlePostClaimMessage(claimedSessionId, socket, parsed);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      httpsServer.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      httpsServer.off("error", onError);
+      resolve();
+    };
+    httpsServer.once("error", onError);
+    httpsServer.once("listening", onListening);
+    httpsServer.listen(options.port);
+  });
+  return {
+    httpsServer,
+    wss,
+    port: () => {
+      const address = httpsServer.address();
+      return address && typeof address !== "string" ? address.port : void 0;
+    },
+    applyTls: (nextMaterial) => {
+      const server = httpsServer;
+      server.setSecureContext?.({ key: nextMaterial.keyPem, cert: nextMaterial.certPem });
+    },
+    close: () => new Promise((resolve) => {
+      for (const client of wss.clients) {
+        client.terminate();
+      }
+      wss.close(() => {
+        httpsServer.closeAllConnections();
+        httpsServer.close(() => resolve());
+      });
+    })
+  };
+};
+
+// src/daemon/policy.ts
+var policyOverrideKey = (alias, toolName) => `${alias}/${toolName}`;
+var evaluate = (descriptor, session, policy) => {
+  const override = policy.tools?.[policyOverrideKey(session.alias, descriptor.name)];
+  if (override !== void 0) {
+    return override;
+  }
+  if (descriptor.annotations?.destructiveHint === true) {
+    return policy.destructive;
+  }
+  return policy.default;
+};
+
+// src/daemon/pidfile.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { open as open2, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+var DaemonAlreadyRunningError = class extends Error {
+  constructor(pid) {
+    super(`Appduct daemon is already running (pid ${pid}).`);
+    this.pid = pid;
+    this.name = "DaemonAlreadyRunningError";
+  }
+};
+var readProcStatus = (pid) => {
+  try {
+    return readFileSync3(`/proc/${pid}/status`, "utf8");
+  } catch {
+    return void 0;
+  }
+};
+var isZombie = (pid, readStatus) => {
+  const status = readStatus(pid);
+  if (status === void 0) {
+    return false;
+  }
+  return /^State:\s*Z\b/mu.test(status);
+};
+var isProcessAlive = (pid, readStatus = readProcStatus) => {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+  return !isZombie(pid, readStatus);
+};
+var readPidFromFile = async (pidFilePath) => {
+  let contents;
+  try {
+    contents = await readFile2(pidFilePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const pid = Number.parseInt(contents.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+};
+var acquirePidfile = async (pidFilePath, options = {}) => {
+  const pid = options.pid ?? process.pid;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      const handle = await open2(pidFilePath, "wx", 384);
+      try {
+        await handle.writeFile(String(pid), "utf8");
+      } finally {
+        await handle.close();
+      }
+      let released = false;
+      return {
+        pid,
+        release: async () => {
+          if (released) {
+            return;
+          }
+          released = true;
+          await rm2(pidFilePath, { force: true });
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const existingPid = await readPidFromFile(pidFilePath);
+      if (existingPid !== void 0 && isProcessAlive(existingPid)) {
+        throw new DaemonAlreadyRunningError(existingPid);
+      }
+      await rm2(pidFilePath, { force: true });
+      await options.onStaleTakeover?.();
+    }
+  }
+  throw new Error(`Failed to acquire the Appduct daemon pidfile at "${pidFilePath}".`);
+};
+
+// src/daemon/rpc-server.ts
+import { createServer } from "node:net";
+import { chmod as chmod2, rm as rm3 } from "node:fs/promises";
+var MAX_LINE_BYTES = 1024 * 1024;
+var MAX_NOTIFY_BUFFERED_BYTES = 4 * 1024 * 1024;
+var isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var hasRequestId = (value) => {
+  return "id" in value;
+};
+var writeErrorLine = (socket, id, code, message, data) => {
+  writeLine(socket, {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, ...data ? { data } : {} }
+  });
+};
+var writeLine = (socket, payload, onFlushed) => {
+  if (socket.destroyed) {
+    return;
+  }
+  socket.write(`${JSON.stringify(payload)}
+`, (error) => {
+    if (!error) {
+      onFlushed?.();
+    }
+  });
+};
+var handleLine = async (line, connection, dispatch, registerOnClose) => {
+  const { socket } = connection;
+  let request;
+  try {
+    const parsed = JSON.parse(line);
+    if (!isPlainObject(parsed)) {
+      writeErrorLine(socket, null, -32600, "Invalid Request: expected a JSON object.");
+      return;
+    }
+    request = parsed;
+  } catch {
+    writeErrorLine(socket, null, -32700, "Parse error: invalid JSON.");
+    return;
+  }
+  const id = hasRequestId(request) ? request.id : null;
+  if (typeof request.method !== "string" || request.method.length === 0) {
+    writeErrorLine(socket, id, -32600, 'Invalid Request: "method" must be a non-empty string.');
+    return;
+  }
+  const handler = dispatch[request.method];
+  if (!handler) {
+    writeErrorLine(socket, id, -32601, `Method not found: "${request.method}".`);
+    return;
+  }
+  const afterSendCallbacks = [];
+  const context = {
+    connection,
+    afterSend: (callback) => {
+      afterSendCallbacks.push(callback);
+    },
+    onClose: registerOnClose
+  };
+  try {
+    const result = await handler(request.params, context);
+    writeLine(socket, { jsonrpc: "2.0", id, result: result ?? null }, () => {
+      for (const callback of afterSendCallbacks) {
+        callback();
+      }
+    });
+  } catch (error) {
+    if (error instanceof RpcApplicationError) {
+      writeErrorLine(socket, id, error.code, error.message, {
+        type: error.type,
+        ...error.details !== void 0 ? { details: error.details } : {}
+      });
+      return;
+    }
+    const message = error instanceof Error ? error.message : "Internal error.";
+    writeErrorLine(socket, id, -32603, message, { type: "invalid_request" });
+  }
+};
+var startRpcServer = async (options) => {
+  const maxLineBytes = options.maxLineBytes ?? MAX_LINE_BYTES;
+  const connections = /* @__PURE__ */ new Map();
+  let nextConnectionId = 1;
+  await rm3(options.socketPath, { force: true });
+  const server = createServer((socket) => {
+    socket.on("error", () => {
+    });
+    const id = nextConnectionId;
+    nextConnectionId += 1;
+    const connection = { id, socket, state: {} };
+    connections.set(id, connection);
+    const closeCallbacks = /* @__PURE__ */ new Set();
+    const registerOnClose = (callback) => {
+      closeCallbacks.add(callback);
+      return () => {
+        closeCallbacks.delete(callback);
+      };
+    };
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      if (Buffer.byteLength(buffer, "utf8") > maxLineBytes && !buffer.includes("\n")) {
+        socket.destroy();
+        return;
+      }
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex).replace(/\r$/u, "");
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line.length > 0) {
+          if (Buffer.byteLength(line, "utf8") > maxLineBytes) {
+            writeErrorLine(
+              socket,
+              null,
+              -32600,
+              `Invalid Request: line exceeds the ${maxLineBytes}-byte limit.`
+            );
+            socket.destroy();
+            return;
+          }
+          void handleLine(line, connection, options.dispatch, registerOnClose);
+        }
+        newlineIndex = buffer.indexOf("\n");
+      }
+    });
+    socket.on("close", () => {
+      connections.delete(id);
+      const callbacks = Array.from(closeCallbacks);
+      closeCallbacks.clear();
+      for (const callback of callbacks) {
+        try {
+          callback();
+        } catch {
+        }
+      }
+    });
+  });
+  server.on("error", () => {
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(options.socketPath);
+  });
+  await chmod2(options.socketPath, 384);
+  return {
+    server,
+    notify: (connection, payload) => {
+      if (connection.socket.destroyed) {
+        return;
+      }
+      if (connection.socket.writableLength > MAX_NOTIFY_BUFFERED_BYTES) {
+        connection.socket.destroy();
+        return;
+      }
+      writeLine(connection.socket, { jsonrpc: "2.0", method: "event", params: payload });
+    },
+    connections: () => Array.from(connections.values()),
+    close: () => new Promise((resolve) => {
+      for (const connection of connections.values()) {
+        connection.socket.destroy();
+      }
+      server.close(() => resolve());
+    })
+  };
+};
+
+// src/daemon/state-dir.ts
+import { join as join4 } from "node:path";
+import { mkdir as mkdir2, chmod as chmod3 } from "node:fs/promises";
+var getStateDirPaths = (stateDir) => {
+  return {
+    root: stateDir,
+    socketPath: join4(stateDir, "daemon.sock"),
+    pidFilePath: join4(stateDir, "daemon.pid"),
+    logFilePath: join4(stateDir, "daemon.log"),
+    keyPath: join4(stateDir, "key.pem"),
+    configPath: join4(stateDir, "config.json"),
+    auditDir: join4(stateDir, "audit"),
+    spawnLockPath: join4(stateDir, "daemon.spawn.lock")
+  };
+};
+var getSocketPath = (paths) => {
+  return paths.socketPath;
+};
+var ensureStateDir = async (stateDir) => {
+  const paths = getStateDirPaths(stateDir);
+  await mkdir2(paths.auditDir, { recursive: true });
+  await chmod3(paths.root, 448);
+  await chmod3(paths.auditDir, 448);
+  return paths;
+};
+
+// src/daemon/tls.ts
+import { stat as stat2, readFile as readFile3 } from "node:fs/promises";
+
+// src/host-certificate.ts
+import "reflect-metadata";
+import {
+  createPrivateKey as createPrivateKey2,
+  createPublicKey as createPublicKey2,
+  webcrypto
+} from "node:crypto";
+import {
+  BasicConstraintsExtension,
+  DNS,
+  ExtendedKeyUsage,
+  ExtendedKeyUsageExtension,
+  IP,
+  KeyUsageFlags,
+  KeyUsagesExtension,
+  SubjectAlternativeNameExtension,
+  SubjectKeyIdentifierExtension,
+  X509CertificateGenerator
+} from "@peculiar/x509";
+
+// src/spki-pin.ts
+import { createHash as createHash2, createPrivateKey, createPublicKey } from "node:crypto";
+var createSpkiPin = (spkiDer) => {
+  const digest = createHash2("sha256").update(spkiDer).digest("base64");
+  return `sha256/${digest}`;
+};
+var getSpkiPinFromPrivateKeyPem = (keyPem) => {
+  const privateKey = createPrivateKey(keyPem);
+  const publicKey = createPublicKey(privateKey);
+  const spkiDer = Buffer.from(
+    publicKey.export({
+      type: "spki",
+      format: "der"
+    })
+  );
+  return createSpkiPin(spkiDer);
+};
+
+// src/host-certificate.ts
+var CERT_VALIDITY_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+var CERT_CLOCK_SKEW_MS = 5 * 60 * 1e3;
+var toArrayBuffer = (view) => {
+  return Uint8Array.from(view).buffer;
+};
+var decodeBase64Url = (value) => {
+  return Uint8Array.from(Buffer.from(value, "base64url"));
+};
+var resolveEcHash = (curve) => {
+  switch (curve) {
+    case "P-256":
+      return "SHA-256";
+    case "P-384":
+      return "SHA-384";
+    case "P-521":
+      return "SHA-512";
+    default:
+      throw new Error(`Unsupported EC named curve "${curve}" for Appduct host certificates.`);
+  }
+};
+var importSigningKeyPair = async (keyPem) => {
+  const privateKeyObject = createPrivateKey2(keyPem);
+  const publicKeyObject = createPublicKey2(privateKeyObject);
+  const privateKeyDer = Buffer.from(privateKeyObject.export({ format: "der", type: "pkcs8" }));
+  const publicKeyDer = Buffer.from(publicKeyObject.export({ format: "der", type: "spki" }));
+  const jwk = privateKeyObject.export({ format: "jwk" });
+  if (jwk.kty === "RSA") {
+    const modulusLength = privateKeyObject.asymmetricKeyDetails?.modulusLength;
+    if (typeof modulusLength !== "number" || typeof jwk.e !== "string") {
+      throw new Error("Appduct could not determine RSA key details for certificate generation.");
+    }
+    const publicExponent = decodeBase64Url(jwk.e);
+    const importAlgorithm = {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: "SHA-256",
+      modulusLength,
+      publicExponent
+    };
+    return {
+      keyType: "rsa",
+      privateKey: await webcrypto.subtle.importKey(
+        "pkcs8",
+        toArrayBuffer(privateKeyDer),
+        importAlgorithm,
+        false,
+        ["sign"]
+      ),
+      publicKey: await webcrypto.subtle.importKey(
+        "spki",
+        toArrayBuffer(publicKeyDer),
+        importAlgorithm,
+        true,
+        ["verify"]
+      ),
+      signingAlgorithm: {
+        name: "RSASSA-PKCS1-v1_5",
+        hash: "SHA-256"
+      }
+    };
+  }
+  if (jwk.kty === "EC") {
+    const namedCurve = jwk.crv;
+    if (typeof namedCurve !== "string") {
+      throw new Error("Appduct could not determine the EC named curve for certificate generation.");
+    }
+    const importAlgorithm = {
+      name: "ECDSA",
+      namedCurve
+    };
+    const signingAlgorithm = {
+      ...importAlgorithm,
+      hash: resolveEcHash(namedCurve)
+    };
+    return {
+      keyType: "ec",
+      privateKey: await webcrypto.subtle.importKey(
+        "pkcs8",
+        toArrayBuffer(privateKeyDer),
+        importAlgorithm,
+        false,
+        ["sign"]
+      ),
+      publicKey: await webcrypto.subtle.importKey(
+        "spki",
+        toArrayBuffer(publicKeyDer),
+        importAlgorithm,
+        true,
+        ["verify"]
+      ),
+      signingAlgorithm: {
+        name: "ECDSA",
+        hash: resolveEcHash(namedCurve)
+      }
+    };
+  }
+  throw new Error(`Appduct does not support "${jwk.kty ?? privateKeyObject.asymmetricKeyType}" host keys.`);
+};
+var generateHostCertificate = async (keyPem, advertisedIp) => {
+  const keys = await importSigningKeyPair(keyPem);
+  const sanEntries = [
+    { type: DNS, value: "localhost" },
+    { type: IP, value: "127.0.0.1" }
+  ];
+  if (advertisedIp !== "127.0.0.1") {
+    sanEntries.push({ type: IP, value: advertisedIp });
+  }
+  const keyUsage = KeyUsageFlags.digitalSignature | (keys.keyType === "rsa" ? KeyUsageFlags.keyEncipherment : KeyUsageFlags.keyAgreement);
+  const certificate = await X509CertificateGenerator.createSelfSigned(
+    {
+      name: "CN=Appduct Host",
+      notBefore: new Date(Date.now() - CERT_CLOCK_SKEW_MS),
+      notAfter: new Date(Date.now() + CERT_VALIDITY_WINDOW_MS),
+      signingAlgorithm: keys.signingAlgorithm,
+      keys: {
+        privateKey: keys.privateKey,
+        publicKey: keys.publicKey
+      },
+      extensions: [
+        new BasicConstraintsExtension(false, void 0, true),
+        new KeyUsagesExtension(keyUsage, true),
+        new ExtendedKeyUsageExtension([ExtendedKeyUsage.serverAuth], false),
+        new SubjectAlternativeNameExtension(sanEntries, false),
+        await SubjectKeyIdentifierExtension.create(keys.publicKey)
+      ]
+    }
+  );
+  const certPem = certificate.toString("pem");
+  return {
+    certPem,
+    spkiPin: getSpkiPinFromPrivateKeyPem(keyPem)
+  };
+};
+
+// src/key-material.ts
+import { generateKeyPairSync } from "node:crypto";
+import { dirname as dirname2 } from "node:path";
+import { mkdir as mkdir3, rename, rm as rm4, writeFile } from "node:fs/promises";
+var generatePrivateKeyPem = () => {
+  const { privateKey } = generateKeyPairSync("rsa", {
+    modulusLength: 2048,
+    publicExponent: 65537
+  });
+  return privateKey.export({
+    format: "pem",
+    type: "pkcs8"
+  }).toString("utf8");
+};
+var writePrivateKeyAtomically = async (path, keyPem) => {
+  const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await mkdir3(dirname2(path), { recursive: true });
+  try {
+    await writeFile(temporaryPath, keyPem, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    await rename(temporaryPath, path);
+  } catch (error) {
+    await rm4(temporaryPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+};
+
+// src/daemon/tls.ts
+var HostKeyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HostKeyError";
+  }
+};
+var loadHostKeyPem = async (keyPath) => {
+  const fileStat = await stat2(keyPath);
+  if ((fileStat.mode & 63) !== 0) {
+    throw new HostKeyError(
+      `Appduct host key at "${keyPath}" is group- or world-readable (mode ${(fileStat.mode & 511).toString(8)}). Refusing to load it \u2014 run "chmod 600 ${keyPath}" or re-run "appduct keygen".`
+    );
+  }
+  return readFile3(keyPath, "utf8");
+};
+var loadOrGenerateHostKeyPem = async (keyPath, warn) => {
+  try {
+    return await loadHostKeyPem(keyPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const keyPem = generatePrivateKeyPem();
+  await writePrivateKeyAtomically(keyPath, keyPem);
+  warn?.(
+    `Appduct: no host key found at "${keyPath}" \u2014 generated one (dev mode). SPKI pin: ${getSpkiPinFromPrivateKeyPem(keyPem)}`
+  );
+  return keyPem;
+};
+var createTlsManager = async (options) => {
+  const keyPem = await loadOrGenerateHostKeyPem(options.keyPath, options.warn);
+  const mint = async (address) => {
+    const { certPem, spkiPin } = await generateHostCertificate(keyPem, address.address);
+    return { certPem, keyPem, spkiPin, advertisedAddress: address };
+  };
+  let material = await mint(options.detectAddress());
+  return {
+    current: () => material,
+    refresh: async (address) => {
+      const next = address ?? options.detectAddress();
+      if (next.address !== material.advertisedAddress.address || next.family !== material.advertisedAddress.family) {
+        material = await mint(next);
+      }
+      return material;
+    },
+    pinnedKeys: () => [material.spkiPin]
+  };
+};
+var toAgentEndpoint = (address, port) => {
+  return { family: address.family, address: address.address, port };
+};
+
+// src/daemon/daemon.ts
+var KNOWN_EVENT_KINDS = new Set(EVENT_KINDS);
+var packageVersion = () => getDaemonReportedVersion();
+var AUDIT_PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var buildStatusResult = async (config, boundWssPort, startedAt, tls, sessionManager, auditLogger, auditDir) => {
+  const stats = await auditLogger.stats();
+  return {
+    version: packageVersion(),
+    pid: process.pid,
+    startedAt: startedAt.toISOString(),
+    wssPort: boundWssPort,
+    pinnedKeys: tls.pinnedKeys(),
+    sessions: sessionManager.list(),
+    pendingLinks: sessionManager.pendingLinkCount(),
+    policy: config.policy,
+    audit: {
+      path: auditDir,
+      failedWrites: auditLogger.failedWrites(),
+      failedPrunes: auditLogger.failedPrunes(),
+      retentionDays: config.auditRetentionDays,
+      files: stats.files,
+      bytes: stats.bytes
+    }
+  };
+};
+var asSelectorParams = (params) => {
+  if (params === void 0 || params === null) {
+    return {};
+  }
+  if (typeof params !== "object" || Array.isArray(params)) {
+    throw new RpcApplicationError("invalid_request", "Params must be an object.");
+  }
+  const selector = params.selector;
+  if (selector !== void 0 && typeof selector !== "string") {
+    throw new RpcApplicationError("invalid_request", '"selector" must be a string.');
+  }
+  return { selector };
+};
+var asToolsListParams = (params) => {
+  const { selector } = asSelectorParams(params);
+  const record = asRecordParams(params);
+  const group = record.group;
+  if (group !== void 0 && !isValidToolGroup(group)) {
+    throw new RpcApplicationError(
+      "invalid_request",
+      '"group" must be one or two "/"-separated segments, each matching [a-zA-Z0-9_-]{1,64}.'
+    );
+  }
+  const filter = record.filter;
+  if (filter !== void 0 && (typeof filter !== "string" || filter.length > MAX_TOOLS_FILTER_LENGTH)) {
+    throw new RpcApplicationError(
+      "invalid_request",
+      `"filter" must be a string of at most ${MAX_TOOLS_FILTER_LENGTH} characters.`
+    );
+  }
+  const limit = record.limit;
+  if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0)) {
+    throw new RpcApplicationError("invalid_request", '"limit" must be a positive integer.');
+  }
+  const offset = record.offset;
+  if (offset !== void 0 && (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0)) {
+    throw new RpcApplicationError("invalid_request", '"offset" must be a non-negative integer.');
+  }
+  return {
+    selector,
+    group,
+    filter,
+    limit,
+    offset
+  };
+};
+var asRecordParams = (params) => {
+  if (params === void 0 || params === null) {
+    return {};
+  }
+  if (typeof params !== "object" || Array.isArray(params)) {
+    throw new RpcApplicationError("invalid_request", "Params must be an object.");
+  }
+  return params;
+};
+var asToolsCallParams = (params) => {
+  const record = asRecordParams(params);
+  const selector = record.selector;
+  if (selector !== void 0 && typeof selector !== "string") {
+    throw new RpcApplicationError("invalid_request", '"selector" must be a string.');
+  }
+  if (typeof record.name !== "string" || record.name.length === 0) {
+    throw new RpcApplicationError("invalid_request", '"name" must be a non-empty string.');
+  }
+  const args = record.args;
+  if (typeof args !== "object" || args === null || Array.isArray(args)) {
+    throw new RpcApplicationError("invalid_request", '"args" must be a JSON object.');
+  }
+  const timeoutMs = record.timeoutMs;
+  if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs))) {
+    throw new RpcApplicationError("invalid_request", '"timeoutMs" must be a number.');
+  }
+  const caller = record.caller;
+  if (caller !== void 0 && caller !== "cli" && caller !== "mcp" && caller !== "client") {
+    throw new RpcApplicationError("invalid_request", '"caller" must be "cli", "mcp", or "client".');
+  }
+  const consent = record.consent;
+  if (consent !== void 0 && consent !== "elicitation" && consent !== "client") {
+    throw new RpcApplicationError("invalid_request", '"consent" must be "elicitation".');
+  }
+  return {
+    selector,
+    name: record.name,
+    args,
+    timeoutMs,
+    caller,
+    consent: consent === "elicitation" ? "elicitation" : void 0
+  };
+};
+var asToolsCancelParams = (params) => {
+  const record = asRecordParams(params);
+  const selector = record.selector;
+  if (selector !== void 0 && typeof selector !== "string") {
+    throw new RpcApplicationError("invalid_request", '"selector" must be a string.');
+  }
+  if (typeof record.callId !== "string" || record.callId.length === 0) {
+    throw new RpcApplicationError("invalid_request", '"callId" must be a non-empty string.');
+  }
+  const reason = record.reason;
+  if (reason !== void 0 && typeof reason !== "string") {
+    throw new RpcApplicationError("invalid_request", '"reason" must be a string.');
+  }
+  return {
+    selector,
+    callId: record.callId,
+    reason
+  };
+};
+var asEventsSubscribeParams = (params) => {
+  const record = asRecordParams(params);
+  const sessionSelector = record.sessionSelector;
+  if (sessionSelector !== void 0 && typeof sessionSelector !== "string") {
+    throw new RpcApplicationError("invalid_request", '"sessionSelector" must be a string.');
+  }
+  const kindsRaw = record.kinds;
+  let kinds;
+  if (kindsRaw !== void 0) {
+    if (!Array.isArray(kindsRaw) || !kindsRaw.every((kind) => typeof kind === "string" && KNOWN_EVENT_KINDS.has(kind))) {
+      throw new RpcApplicationError("invalid_request", '"kinds" must be an array of known event kinds.');
+    }
+    kinds = kindsRaw;
+  }
+  return { sessionSelector, kinds };
+};
+var asEventsSinceParams = (params) => {
+  const record = asRecordParams(params);
+  const selector = record.selector;
+  if (selector !== void 0 && typeof selector !== "string") {
+    throw new RpcApplicationError("invalid_request", '"selector" must be a string.');
+  }
+  const since = record.since;
+  if (since !== void 0 && (typeof since !== "number" || !Number.isInteger(since) || since < 0)) {
+    throw new RpcApplicationError("invalid_request", '"since" must be a non-negative integer.');
+  }
+  const kindsRaw = record.kinds;
+  let kinds;
+  if (kindsRaw !== void 0) {
+    if (!Array.isArray(kindsRaw) || !kindsRaw.every((kind) => typeof kind === "string" && KNOWN_EVENT_KINDS.has(kind))) {
+      throw new RpcApplicationError("invalid_request", '"kinds" must be an array of known event kinds.');
+    }
+    kinds = kindsRaw;
+  }
+  const limit = record.limit;
+  if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0)) {
+    throw new RpcApplicationError("invalid_request", '"limit" must be a positive integer.');
+  }
+  return {
+    selector,
+    since,
+    kinds,
+    limit
+  };
+};
+var asLinkCreateParams = (params) => {
+  if (params === void 0 || params === null) {
+    return {};
+  }
+  if (typeof params !== "object" || Array.isArray(params)) {
+    throw new RpcApplicationError("invalid_request", "Params must be an object.");
+  }
+  const record = params;
+  const ttlSeconds = record.ttlSeconds;
+  if (ttlSeconds !== void 0 && (typeof ttlSeconds !== "number" || !Number.isInteger(ttlSeconds) || ttlSeconds <= 0)) {
+    throw new RpcApplicationError("invalid_request", '"ttlSeconds" must be a positive integer.');
+  }
+  const addressOverride = record.addressOverride;
+  if (addressOverride !== void 0 && (typeof addressOverride !== "string" || addressOverride.length === 0)) {
+    throw new RpcApplicationError("invalid_request", '"addressOverride" must be a non-empty string.');
+  }
+  return { ttlSeconds, addressOverride };
+};
+var startDaemon = async (options) => {
+  const clock = options.clock ?? { now: () => /* @__PURE__ */ new Date() };
+  const timers = options.timers ?? systemTimers;
+  const paths = getStateDirPaths(options.stateDir);
+  await ensureStateDir(options.stateDir);
+  const config = await loadConfig(paths, { warn: options.warn });
+  const startedAt = clock.now();
+  const auditLogger = createAuditLogger({
+    auditDir: paths.auditDir,
+    clock,
+    retentionDays: config.auditRetentionDays,
+    warn: options.warn
+  });
+  let auditPruneInterval;
+  let pidfile;
+  let server;
+  let listener;
+  let sessionManager;
+  let callsManager;
+  let eventBus;
+  let boundWssPort = config.wssPort;
+  let shuttingDown = false;
+  let resolveExited;
+  const exited = new Promise((resolve) => {
+    resolveExited = resolve;
+  });
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return exited;
+    }
+    shuttingDown = true;
+    try {
+      if (auditPruneInterval !== void 0) {
+        timers.clearInterval(auditPruneInterval);
+        auditPruneInterval = void 0;
+      }
+      callsManager?.disposeAll();
+      sessionManager?.disposeAll(1001, "daemon_shutdown");
+      await listener?.close();
+      await server?.close();
+      await pidfile?.release();
+      await rm5(getSocketPath(paths), { force: true });
+      await auditLogger.flush();
+    } finally {
+      resolveExited();
+    }
+  };
+  try {
+    pidfile = await acquirePidfile(paths.pidFilePath, {
+      onStaleTakeover: async () => {
+        await rm5(getSocketPath(paths), { force: true });
+      }
+    });
+    eventBus = createEventBus({ clock, bufferSize: config.eventBufferSize });
+    const activeEventBus = eventBus;
+    const detectAddress = options.detectAddress ?? (() => detectAdvertisedAddress({ override: config.advertisedIp }));
+    const tls = await createTlsManager({ keyPath: config.keyPath, detectAddress, warn: options.warn });
+    sessionManager = createSessionManager({
+      graceSeconds: config.graceSeconds,
+      keepaliveIntervalSeconds: config.keepaliveIntervalSeconds,
+      linkTtlSeconds: config.linkTtlSeconds,
+      // `boundWssPort`, not `config.wssPort`: a link minted by a daemon on an OS-assigned port
+      // must advertise the port the app can actually reach, not the `0` that asked for one.
+      getEndpoint: () => toAgentEndpoint(tls.current().advertisedAddress, boundWssPort),
+      eventBus: activeEventBus,
+      clock,
+      onToolFrame: (message) => {
+        switch (message.type) {
+          case "tool_result":
+            callsManager?.handleToolResult(message);
+            return;
+          case "tool_error":
+            callsManager?.handleToolError(message);
+            return;
+          case "tool_call_progress":
+            callsManager?.handleToolCallProgress(message);
+        }
+      },
+      onAppEvent: (sessionId, alias, message) => {
+        activeEventBus.emit({
+          kind: "app_event",
+          sessionId,
+          alias,
+          data: { name: message.name, payload: message.payload, ts: message.ts }
+        });
+      }
+    });
+    const activeSessionManager = sessionManager;
+    callsManager = createCallsManager({
+      send: (sessionId, message) => activeSessionManager.sendToolCall(sessionId, message),
+      sendCancel: (sessionId, message) => activeSessionManager.sendToolCancel(sessionId, message),
+      eventBus: activeEventBus
+    });
+    const activeCallsManager = callsManager;
+    listener = await startListener({
+      port: config.wssPort,
+      tls,
+      sessionManager
+    });
+    const activeListener = listener;
+    boundWssPort = activeListener.port() ?? config.wssPort;
+    activeEventBus.subscribe((event) => {
+      for (const connection of server?.connections() ?? []) {
+        const subscription = connection.state.eventSubscription;
+        if (!subscription) {
+          continue;
+        }
+        if (subscription.kinds && !subscription.kinds.has(event.kind)) {
+          continue;
+        }
+        if (subscription.sessionSelector !== void 0 && event.sessionId !== subscription.sessionSelector && event.alias !== subscription.sessionSelector) {
+          continue;
+        }
+        server?.notify(connection, event);
+      }
+    });
+    server = await startRpcServer({
+      socketPath: getSocketPath(paths),
+      dispatch: {
+        [RPC_METHODS.daemonStatus]: async () => {
+          return buildStatusResult(
+            config,
+            boundWssPort,
+            startedAt,
+            tls,
+            activeSessionManager,
+            auditLogger,
+            paths.auditDir
+          );
+        },
+        [RPC_METHODS.daemonShutdown]: (_params, context) => {
+          context.afterSend(() => {
+            void shutdown();
+          });
+          return { ok: true };
+        },
+        [RPC_METHODS.linkCreate]: async (params) => {
+          const { ttlSeconds, addressOverride } = asLinkCreateParams(params);
+          const previousMaterial = tls.current();
+          const nextMaterial = await tls.refresh();
+          if (nextMaterial !== previousMaterial) {
+            activeListener.applyTls(nextMaterial);
+          }
+          return { ...activeSessionManager.createLink(ttlSeconds, addressOverride), pin: tls.pinnedKeys()[0] };
+        },
+        [RPC_METHODS.sessionsList]: () => {
+          return activeSessionManager.list();
+        },
+        [RPC_METHODS.sessionsDescribe]: (params) => {
+          const { selector } = asSelectorParams(params);
+          return activeSessionManager.describe(selector);
+        },
+        [RPC_METHODS.sessionsRevoke]: (params) => {
+          const { selector } = asSelectorParams(params);
+          activeSessionManager.revoke(selector);
+          return { ok: true };
+        },
+        [RPC_METHODS.toolsList]: (params) => {
+          const { selector, group, filter, limit, offset } = asToolsListParams(params);
+          const resolved = activeSessionManager.resolveForTools(selector);
+          const entries = resolved.registry.list().map((descriptor) => ({
+            ...descriptor,
+            // Normalised once, here, so every reader of a listing finds the key: an app registers an
+            // ungrouped tool by omitting `group`, a listing reports it as `null` — the same value the
+            // `groups` summary uses for its ungrouped bucket.
+            group: descriptor.group ?? null,
+            policy: evaluate(descriptor, { alias: resolved.alias }, config.policy)
+          }));
+          entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+          const groups = summarizeToolGroups(entries);
+          const inGroup = group === void 0 ? entries : entries.filter((entry) => toolGroupMatches(entry.group, group));
+          const lowerFilter = filter?.toLowerCase();
+          const matching = lowerFilter ? inGroup.filter(
+            (entry) => entry.name.toLowerCase().includes(lowerFilter) || entry.description.toLowerCase().includes(lowerFilter)
+          ) : inGroup;
+          const total = matching.length;
+          const page = offset === void 0 && limit === void 0 ? matching : matching.slice(offset ?? 0, limit === void 0 ? void 0 : (offset ?? 0) + limit);
+          return { tools: page, total, groups };
+        },
+        // This handler is the single seam every `tools.call` passes through: policy (ARCHITECTURE.md
+        // §12) is evaluated once the target tool descriptor is known, and one audit record is
+        // written for every attempt that reaches a resolved session, across ok/error/denied.
+        [RPC_METHODS.toolsCall]: async (params, context) => {
+          const { selector, name, args, timeoutMs, caller, consent } = asToolsCallParams(params);
+          const effectiveCaller = caller ?? "cli";
+          const resolved = activeSessionManager.resolveForTools(selector);
+          const auditStartedAt = clock.now().getTime();
+          const writeAudit = (outcome, errorType, grantedConsent2, deniedReason) => {
+            auditLogger.record({
+              sessionId: resolved.sessionId,
+              alias: resolved.alias,
+              tool: name,
+              argsSha256: argsSha256(args),
+              outcome,
+              errorType,
+              deniedReason,
+              durationMs: clock.now().getTime() - auditStartedAt,
+              caller: effectiveCaller,
+              consent: grantedConsent2
+            });
+          };
+          if (resolved.state !== "active") {
+            const errorType = resolved.state === "suspended" ? "session_suspended" : "session_not_active";
+            writeAudit("error", errorType);
+            throw new RpcApplicationError(errorType, `Session "${resolved.alias}" is not active.`);
+          }
+          const tool = resolved.registry.get(name);
+          if (!tool) {
+            writeAudit("error", "tool_not_found");
+            throw new RpcApplicationError("tool_not_found", `Tool "${name}" is not registered.`);
+          }
+          const policyDecision = evaluate(tool, { alias: resolved.alias }, config.policy);
+          const grantedConsent = policyDecision === "prompt" && consent === "elicitation" ? consent : void 0;
+          if (policyDecision === "deny" || policyDecision === "prompt" && grantedConsent === void 0) {
+            activeEventBus.emit({
+              kind: "tool_call_finished",
+              sessionId: resolved.sessionId,
+              alias: resolved.alias,
+              data: { name, outcome: "denied" }
+            });
+            if (policyDecision === "prompt") {
+              writeAudit("denied", void 0, void 0, "no_consent_channel");
+              throw new RpcApplicationError(
+                "policy_denied",
+                `Policy requires prompt consent to call "${name}" on session "${resolved.alias}", but no consent channel confirmed it.`,
+                -32e3,
+                {
+                  reason: "no_consent_channel",
+                  hint: `This caller did not confirm human consent for "${name}". Only an MCP client that declares the "elicitation" capability can confirm it, via an elicitation/create prompt; every other caller (including the CLI and MCP clients without elicitation) is denied by design. To change this tool's policy, edit "policy.tools["${resolved.alias}/${name}"]" (or policy.default/policy.destructive) in ${paths.configPath}.`
+                }
+              );
+            }
+            writeAudit("denied", void 0, void 0, "policy");
+            throw new RpcApplicationError(
+              "policy_denied",
+              `Policy denies calling "${name}" on session "${resolved.alias}".`,
+              -32e3,
+              { hint: `Edit "policy" in ${paths.configPath} (policy.default/policy.destructive/policy.tools) to change this.` }
+            );
+          }
+          const startedAt2 = clock.now().getTime();
+          const session = { sessionId: resolved.sessionId, alias: resolved.alias };
+          const { callId, result: callResult } = activeCallsManager.call(
+            session,
+            name,
+            args,
+            // The caller's explicit `timeoutMs` wins; otherwise the tool's own declared deadline is
+            // the default, and only if it declares none does `clampTimeout` fall back to
+            // DEFAULT_CALL_TIMEOUT_MS (issue #25).
+            timeoutMs ?? tool.timeout_ms
+          );
+          const unregisterOnClose = context.onClose(() => {
+            activeCallsManager.cancel(resolved.sessionId, callId, "connection_closed");
+          });
+          activeEventBus.emit({
+            kind: "tool_call_started",
+            sessionId: resolved.sessionId,
+            alias: resolved.alias,
+            data: { name, callId }
+          });
+          try {
+            const result = await callResult;
+            activeEventBus.emit({
+              kind: "tool_call_finished",
+              sessionId: resolved.sessionId,
+              alias: resolved.alias,
+              data: { name, callId, durationMs: clock.now().getTime() - startedAt2, outcome: "ok" }
+            });
+            writeAudit("ok", void 0, grantedConsent);
+            return { result, callId };
+          } catch (error) {
+            const errorType = error instanceof RpcApplicationError ? error.type : "tool_execution_error";
+            const outcome = errorType === "tool_cancelled" ? "cancelled" : "error";
+            activeEventBus.emit({
+              kind: "tool_call_finished",
+              sessionId: resolved.sessionId,
+              alias: resolved.alias,
+              data: { name, callId, durationMs: clock.now().getTime() - startedAt2, outcome, errorType }
+            });
+            writeAudit(outcome, errorType, grantedConsent);
+            throw error;
+          } finally {
+            unregisterOnClose();
+          }
+        },
+        [RPC_METHODS.toolsCancel]: (params) => {
+          const { selector, callId, reason } = asToolsCancelParams(params);
+          const resolved = activeSessionManager.resolveForTools(selector);
+          const cancelled = activeCallsManager.cancel(resolved.sessionId, callId, reason ?? "client_cancelled");
+          return { cancelled };
+        },
+        [RPC_METHODS.eventsSubscribe]: (params, context) => {
+          const { sessionSelector, kinds } = asEventsSubscribeParams(params);
+          context.connection.state.eventSubscription = {
+            sessionSelector,
+            kinds: kinds ? new Set(kinds) : void 0
+          };
+          return { ok: true };
+        },
+        [RPC_METHODS.eventsSince]: (params) => {
+          const { selector, since, kinds, limit } = asEventsSinceParams(params);
+          const resolved = activeSessionManager.describe(selector);
+          return activeEventBus.since(resolved.sessionId, { since, kinds, limit });
+        }
+      }
+    });
+    auditPruneInterval = timers.setInterval(() => {
+      void auditLogger.prune();
+    }, AUDIT_PRUNE_INTERVAL_MS);
+    void auditLogger.prune();
+  } catch (error) {
+    if (auditPruneInterval !== void 0) {
+      timers.clearInterval(auditPruneInterval);
+      auditPruneInterval = void 0;
+    }
+    callsManager?.disposeAll();
+    sessionManager?.disposeAll(1001, "daemon_startup_failed");
+    await listener?.close();
+    await pidfile?.release();
+    throw error;
+  }
+  eventBus.emit({ kind: "daemon_started", data: { version: packageVersion(), pid: process.pid } });
+  return {
+    paths,
+    config,
+    startedAt,
+    server,
+    listener,
+    eventBus,
+    exited,
+    shutdown
+  };
+};
+
+// src/rpc/client.ts
+import { join as join5 } from "node:path";
+import { RPC_METHODS as RPC_METHODS2 } from "@appduct/shared";
+var defaultBinPath = join5(getPackageRoot(), "bin.js");
+var DaemonRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "DaemonRpcError";
+  }
+};
+var DaemonUnavailableError = class extends Error {
+  constructor(message, reason = "unreachable") {
+    super(message);
+    this.reason = reason;
+    this.name = "DaemonUnavailableError";
+  }
+};
+var describeLiveState = (state) => {
+  const parts = [];
+  if (state.sessions > 0) {
+    parts.push(`${state.sessions} connected session(s)`);
+  }
+  if (state.pendingLinks > 0) {
+    parts.push(`${state.pendingLinks} unclaimed link(s)`);
+  }
+  return parts.join(" and ");
+};
+var DaemonVersionMismatchError = class extends Error {
+  constructor(daemonVersion, clientVersion, live, message) {
+    super(
+      message ?? `The running Appduct daemon is version ${daemonVersion}, but this client is version ${clientVersion}. It was not restarted automatically because ${describeLiveState(live)} would be lost. Run "appduct daemon stop" once that state is expendable, or force it with "--daemon-restart".`
+    );
+    this.daemonVersion = daemonVersion;
+    this.clientVersion = clientVersion;
+    this.name = "DaemonVersionMismatchError";
+    this.sessionCount = live.sessions;
+    this.pendingLinkCount = live.pendingLinks;
+  }
+  sessionCount;
+  pendingLinkCount;
+};
+var isConnectionMissingError = (error) => {
+  const code = error.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+};
+var isDaemonUnreachableError = (error) => {
+  return error instanceof DaemonUnavailableError || isConnectionMissingError(error);
+};
+
+// src/errors.ts
+var EXIT_CODE_BY_ERROR_TYPE = {
+  usage_error: 64,
+  validation_error: 65,
+  // EX_NOINPUT (66): "an input file did not exist or was not readable" — `doctor` throws this for a
+  // missing external tool or an unreadable/corrupt artifact, deliberately distinct from every other
+  // code here so a release pipeline can't mistake "we couldn't tell" for either a clean pass or an
+  // assertion failure (docs/tasks/08-appduct-doctor.md).
+  inspection_error: 66,
+  connection_error: 70,
+  session_error: 71,
+  tool_error: 72,
+  permission_error: 77,
+  internal_error: 1,
+  // `doctor --assert-present`/`--assert-absent`: the artifact was inspected successfully and the
+  // assertion did not hold. Distinct from `inspection_error` (66) — this means the answer is known
+  // and it's "no", not "couldn't tell" — and distinct from `internal_error` (1) so a caller can't
+  // conflate a normal assertion failure with an unexpected crash.
+  assertion_error: 3
+};
+var RPC_ERROR_EXIT_CLASS = {
+  no_session: "session_error",
+  ambiguous_session: "session_error",
+  unknown_session: "session_error",
+  session_not_active: "session_error",
+  session_suspended: "session_error",
+  tool_not_found: "tool_error",
+  tool_input_validation_error: "tool_error",
+  tool_output_validation_error: "tool_error",
+  tool_execution_error: "tool_error",
+  tool_serialization_error: "tool_error",
+  tool_timeout: "tool_error",
+  tool_cancelled: "tool_error",
+  policy_denied: "permission_error",
+  invalid_request: "validation_error"
+};
+var AppductCliError = class extends Error {
+  type;
+  details;
+  constructor(type, message, details) {
+    super(message);
+    this.name = "AppductCliError";
+    this.type = type;
+    this.details = details;
+  }
+};
+var connectionError = (message, details) => {
+  return new AppductCliError("connection_error", message, details);
+};
+var isAppductCliError = (value) => {
+  return value instanceof AppductCliError;
+};
+var rpcErrorClass = (error) => {
+  const type = error.data?.type;
+  return type ? RPC_ERROR_EXIT_CLASS[type] : void 0;
+};
+var toCliError = (error) => {
+  if (isAppductCliError(error)) {
+    return {
+      type: error.type,
+      message: error.message,
+      details: error.details
+    };
+  }
+  if (error instanceof DaemonVersionMismatchError) {
+    return {
+      type: "connection_error",
+      message: error.message,
+      details: {
+        daemon_version: error.daemonVersion,
+        client_version: error.clientVersion,
+        session_count: error.sessionCount,
+        pending_link_count: error.pendingLinkCount
+      }
+    };
+  }
+  if (error instanceof DaemonRpcError && error.data?.type) {
+    return {
+      type: error.data.type,
+      message: error.message,
+      details: error.data.details
+    };
+  }
+  if (isDaemonUnreachableError(error)) {
+    return {
+      type: "connection_error",
+      message: error instanceof Error ? error.message : "The Appduct daemon is unreachable."
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      type: "internal_error",
+      message: error.message
+    };
+  }
+  return {
+    type: "internal_error",
+    message: "An unexpected error occurred.",
+    details: error
+  };
+};
+var getExitCodeForError = (error) => {
+  if (isAppductCliError(error)) {
+    return EXIT_CODE_BY_ERROR_TYPE[error.type];
+  }
+  if (error instanceof DaemonVersionMismatchError) {
+    return EXIT_CODE_BY_ERROR_TYPE.connection_error;
+  }
+  if (error instanceof DaemonRpcError) {
+    const cliErrorClass = rpcErrorClass(error);
+    return EXIT_CODE_BY_ERROR_TYPE[cliErrorClass ?? "internal_error"];
+  }
+  if (isDaemonUnreachableError(error)) {
+    return EXIT_CODE_BY_ERROR_TYPE.connection_error;
+  }
+  return EXIT_CODE_BY_ERROR_TYPE.internal_error;
+};
+
+// src/commands/daemon/run.ts
+var handleDaemonRunCommand = async (context) => {
+  let daemon;
+  try {
+    daemon = await startDaemon({
+      stateDir: context.stateDir,
+      clock: context.clock,
+      warn: context.warn
+    });
+  } catch (error) {
+    if (error instanceof DaemonAlreadyRunningError) {
+      throw connectionError(error.message, { pid: error.pid });
+    }
+    throw error;
+  }
+  return {
+    result: {
+      ok: true,
+      data: {
+        daemon: {
+          pid: process.pid,
+          state_dir: daemon.paths.root,
+          socket_path: daemon.paths.socketPath
+        }
+      }
+    },
+    completion: daemon.exited,
+    stop: () => {
+      void daemon.shutdown();
+    }
+  };
+};
+
+// src/cli/global-flags.ts
+var formatJson = (value, flags) => {
+  return flags.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+};
+
+// src/output.ts
+import pc from "picocolors";
+import {
+  formatAgentWebSocketUrl,
+  renderToolSignature,
+  summarizeToolDescription
+} from "@appduct/shared";
+
+// src/qr-terminal.ts
+import { toQR } from "toqr";
+var HALF_UPPER = "\u2580";
+var HALF_LOWER = "\u2584";
+var FULL = "\u2588";
+var renderQrToTerminal = (content, options) => {
+  const margin = options?.margin ?? 0;
+  const ecLevel = options?.ecLevel ?? 1;
+  const modules = toQR(content, ecLevel);
+  const side = Math.sqrt(modules.length);
+  if (!Number.isInteger(side)) {
+    throw new Error("Invalid QR matrix size");
+  }
+  const dim = side + 2 * margin;
+  const isDark = (row, col) => {
+    if (row < margin || col < margin || row >= margin + side || col >= margin + side) {
+      return false;
+    }
+    const mr = row - margin;
+    const mc = col - margin;
+    return modules[mr * side + mc] === 1;
+  };
+  const lines = [];
+  for (let row = 0; row < dim; row += 2) {
+    let line = "";
+    for (let col = 0; col < dim; col++) {
+      const top = isDark(row, col);
+      const bottom = row + 1 < dim ? isDark(row + 1, col) : false;
+      line += top ? bottom ? FULL : HALF_UPPER : bottom ? HALF_LOWER : " ";
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+};
+
+// src/output.ts
+var renderMetaLines = (meta) => {
+  if (!meta) {
+    return [];
+  }
+  return [
+    "Meta",
+    `  Command: ${meta.command}`,
+    `  Timestamp: ${meta.timestamp}`,
+    ...typeof meta.duration_ms === "number" ? [`  Duration: ${meta.duration_ms} ms`] : []
+  ];
+};
+var formatScalar = (value, flags) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  return formatJson(value, flags);
+};
+var renderFields = (title, fields, flags) => {
+  const visibleFields = fields.filter(([, value]) => value !== void 0);
+  if (visibleFields.length === 0) {
+    return [];
+  }
+  const width = Math.max(...visibleFields.map(([label]) => label.length));
+  return [
+    title,
+    ...visibleFields.map(([label, value]) => `  ${label.padEnd(width)}  ${formatScalar(value, flags)}`)
+  ];
+};
+var formatAge = (fromIso, toIso) => {
+  const elapsedMs = Math.max(0, new Date(toIso).getTime() - new Date(fromIso).getTime());
+  const elapsedSeconds = Math.floor(elapsedMs / 1e3);
+  if (elapsedSeconds < 60) {
+    return `${elapsedSeconds}s`;
+  }
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  if (elapsedMinutes < 60) {
+    return `${elapsedMinutes}m`;
+  }
+  const elapsedHours = Math.floor(elapsedMinutes / 60);
+  if (elapsedHours < 24) {
+    return `${elapsedHours}h`;
+  }
+  return `${Math.floor(elapsedHours / 24)}d`;
+};
+var formatDevice = (device) => {
+  const parts = [device.manufacturer, device.model].filter((part) => Boolean(part));
+  const label = parts.length > 0 ? parts.join(" ") : "unknown device";
+  return device.os ? `${label} (${device.os})` : label;
+};
+var renderLsData = (colors, data, now) => {
+  if (data.length === 0) {
+    return [colors.dim("Sessions"), "  No Appduct sessions are registered."];
+  }
+  const nowIso = now.toISOString();
+  const headers = ["Alias", "State", "Device", "Tools", "Age"];
+  const rows = data.map((session) => [
+    session.alias,
+    session.state,
+    formatDevice(session.device),
+    String(session.toolCount),
+    formatAge(session.claimedAt ?? session.createdAt, nowIso)
+  ]);
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => row[index].length))
+  );
+  return [
+    colors.green("Sessions"),
+    `  ${headers.map((header, index) => header.padEnd(widths[index])).join("  ")}`,
+    ...rows.map((row) => `  ${row.map((cell, index) => cell.padEnd(widths[index])).join("  ")}`)
+  ];
+};
+var isToolsListing = (data) => {
+  return typeof data === "object" && data !== null && Array.isArray(data.tools);
+};
+var isToolGroupsListing = (data) => {
+  return typeof data === "object" && data !== null && Array.isArray(data.groups) && !Array.isArray(data.tools);
+};
+var UNGROUPED_LABEL = "(ungrouped)";
+var MAX_FOOTER_GROUPS = 10;
+var hasAnyGroup = (groups) => {
+  return (groups ?? []).some((entry) => entry.group !== null);
+};
+var topLevelGroups = (groups) => {
+  return (groups ?? []).filter((entry) => entry.group !== null && !entry.group.includes("/"));
+};
+var renderEmptyToolsLine = (data) => {
+  if (data.total > 0) {
+    return `  No tools at offset ${data.offset ?? 0}; ${data.total} matching tool${data.total === 1 ? "" : "s"} in total.`;
+  }
+  if (data.group !== void 0) {
+    const match = data.filter === void 0 ? "" : ` match ${JSON.stringify(data.filter)}`;
+    return `  No tools in group ${JSON.stringify(data.group)}${match}. Run \`appduct tools --groups\` to see the session's groups.`;
+  }
+  return data.filter === void 0 ? "  No tools registered." : `  No tools match ${JSON.stringify(data.filter)}.`;
+};
+var renderGroupHint = (data) => {
+  if (data.group !== void 0 || !hasAnyGroup(data.groups)) {
+    return void 0;
+  }
+  const top = topLevelGroups(data.groups);
+  const named = top.slice(0, MAX_FOOTER_GROUPS).map((entry) => `${entry.group} ${entry.total}`);
+  const more = top.length > MAX_FOOTER_GROUPS ? `, ... ${top.length - MAX_FOOTER_GROUPS} more; see --groups` : "";
+  return `--group <name> (groups: ${named.join(", ")}${more})`;
+};
+var renderTruncationLine = (data) => {
+  if (data.tools.length >= data.total) {
+    return [];
+  }
+  const groupHint = renderGroupHint(data);
+  const narrow = groupHint === void 0 ? "--filter <text> or" : `${groupHint} or --filter <text>, or`;
+  return [
+    "",
+    `Showing ${data.tools.length} of ${data.total} tools (offset ${data.offset ?? 0}). Narrow with ${narrow} page with --offset <n>.`
+  ];
+};
+var renderToolSummaryLines = (tool, indent) => {
+  const tag = tool.policy === "allow" ? "" : `  [${tool.policy}]`;
+  return [`${indent}${renderToolSignature(tool)}${tag}`, `${indent}  ${summarizeToolDescription(tool.description)}`];
+};
+var renderGroupedToolLines = (colors, tools) => {
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const key = tool.group ?? null;
+    const bucket = byGroup.get(key);
+    if (bucket) {
+      bucket.push(tool);
+    } else {
+      byGroup.set(key, [tool]);
+    }
+  }
+  const tops = /* @__PURE__ */ new Map();
+  for (const key of byGroup.keys()) {
+    if (key === null) {
+      continue;
+    }
+    const slash = key.indexOf("/");
+    const top = slash === -1 ? key : key.slice(0, slash);
+    const subs = tops.get(top) ?? [];
+    if (slash !== -1) {
+      subs.push(key);
+    }
+    tops.set(top, subs);
+  }
+  const byCodePoint = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  const lines = [];
+  for (const top of [...tops.keys()].sort(byCodePoint)) {
+    lines.push(`  ${colors.cyan(top)}`);
+    lines.push(...(byGroup.get(top) ?? []).flatMap((tool) => renderToolSummaryLines(tool, "    ")));
+    for (const sub of tops.get(top).sort(byCodePoint)) {
+      lines.push(`    ${colors.cyan(sub)}`);
+      lines.push(...byGroup.get(sub).flatMap((tool) => renderToolSummaryLines(tool, "      ")));
+    }
+  }
+  const ungrouped = byGroup.get(null);
+  if (ungrouped) {
+    lines.push(`  ${colors.cyan(UNGROUPED_LABEL)}`);
+    lines.push(...ungrouped.flatMap((tool) => renderToolSummaryLines(tool, "    ")));
+  }
+  return lines;
+};
+var renderToolsTitle = (colors, data) => {
+  return colors.green(data.group === void 0 ? "Tools" : `Tools in group ${data.group}`);
+};
+var renderToolSummaryTable = (colors, data) => {
+  if (data.tools.length === 0) {
+    return [renderToolsTitle(colors, data), renderEmptyToolsLine(data)];
+  }
+  const grouped = data.group === void 0 && hasAnyGroup(data.groups);
+  return [
+    renderToolsTitle(colors, data),
+    ...grouped ? renderGroupedToolLines(colors, data.tools) : data.tools.flatMap((tool) => renderToolSummaryLines(tool, "  ")),
+    ...renderTruncationLine(data),
+    "",
+    "Run `appduct tools <name>` for a tool's full schema."
+  ];
+};
+var renderToolDetail = (colors, tool, flags) => {
+  return renderFields(
+    colors.green(`Tool: ${tool.name}`),
+    [
+      ["Signature", renderToolSignature(tool)],
+      ["Description", tool.description],
+      ["Input schema", tool.input_schema],
+      ["Output schema", tool.output_schema],
+      // `?? undefined` keeps an ungrouped tool's row hidden rather than printing a bare "null":
+      // `renderFields` drops undefined rows, and the machine form's `null` is for consumers, not
+      // for a human scanning one tool's schema.
+      ["Group", tool.group ?? void 0],
+      ["Annotations", tool.annotations],
+      // Only rendered for a tool that declares one; `renderFields` drops undefined rows, so a
+      // tool on the daemon's default deadline shows no line at all rather than a misleading
+      // "10000".
+      ["Timeout (ms)", tool.timeout_ms]
+    ],
+    flags
+  );
+};
+var renderToolsFullListing = (colors, data, flags) => {
+  if (data.tools.length === 0) {
+    return [renderToolsTitle(colors, data), renderEmptyToolsLine(data)];
+  }
+  return [
+    ...data.tools.flatMap((tool, index) => [
+      ...index > 0 ? [""] : [],
+      ...renderToolDetail(colors, tool, flags)
+    ]),
+    ...renderTruncationLine(data)
+  ];
+};
+var renderToolGroups = (colors, data) => {
+  if (data.groups.length === 0) {
+    return [colors.green("Groups"), "  No tools registered."];
+  }
+  const label = (entry) => {
+    if (entry.group === null) {
+      return UNGROUPED_LABEL;
+    }
+    return entry.group.includes("/") ? `  ${entry.group}` : entry.group;
+  };
+  const width = Math.max(...data.groups.map((entry) => label(entry).length));
+  const countWidth = Math.max(...data.groups.map((entry) => String(entry.total).length));
+  return [
+    colors.green("Groups"),
+    ...data.groups.map((entry) => `  ${label(entry).padEnd(width)}  ${String(entry.total).padStart(countWidth)}`),
+    "",
+    `${data.total} tool${data.total === 1 ? "" : "s"} in total. ` + (hasAnyGroup(data.groups) ? "Run `appduct tools --group <name>` to list one group's tools." : "No tool declares a group.")
+  ];
+};
+var renderToolsData = (colors, data, flags, full) => {
+  if (isToolGroupsListing(data)) {
+    return renderToolGroups(colors, data);
+  }
+  if (!isToolsListing(data)) {
+    return renderToolDetail(colors, data, flags);
+  }
+  return full ? renderToolsFullListing(colors, data, flags) : renderToolSummaryTable(colors, data);
+};
+var renderInvokeData = (colors, data, flags) => {
+  return [colors.green("Result"), formatScalar(data, flags)];
+};
+var renderLinkData = (colors, data, flags, qr) => {
+  const lines = [
+    colors.green("Link Created"),
+    ...renderFields(
+      "Link",
+      [
+        ["Session", data.sessionId],
+        ["Deep link", data.deepLink],
+        ["Endpoint", formatAgentWebSocketUrl(data.endpoint)],
+        ["Pin", data.pin],
+        ["Expires", new Date(data.expiresAt * 1e3).toISOString()],
+        ["Delivered", data.delivered ? `yes (${data.target})` : void 0]
+      ],
+      flags
+    )
+  ];
+  if (qr) {
+    lines.push("", "QR", renderQrToTerminal(data.deepLink));
+  }
+  return lines;
+};
+var renderRevokeData = (colors, _data) => {
+  return [colors.green("Session Revoked")];
+};
+var renderKeygenData = (colors, data, flags) => {
+  return [
+    colors.green("Key Ready"),
+    ...renderFields(
+      "Key",
+      [
+        ["Path", data.path],
+        ["Fingerprint", data.pin]
+      ],
+      flags
+    )
+  ];
+};
+var renderInitData = (colors, data, flags) => {
+  const snippet = JSON.stringify(
+    { mcpServers: { appduct: data.mcpServerEntry } },
+    null,
+    2
+  );
+  return [
+    colors.green(data.changed ? "Project Initialized" : "Project Already Initialized"),
+    ...renderFields(
+      "Config",
+      [
+        ["Path", data.path],
+        ["Scheme", data.scheme],
+        ["Source", data.source],
+        // Only present for a scheme discovery read off a static project file (app.json, or one of
+        // the native Android/iOS probes) — names the exact file/key, not just which platform.
+        ["Read from", data.origin],
+        ["Written", data.changed ? data.created ? "created" : "updated" : "unchanged"]
+      ],
+      flags
+    ),
+    ...data.note === void 0 ? [] : ["", colors.yellow(`Note: ${data.note}`)],
+    "",
+    "MCP server entry",
+    ...snippet.split("\n").map((line) => `  ${line}`),
+    "",
+    "Next",
+    ...data.nextSteps.map((step, index) => `  ${index + 1}. ${step}`)
+  ];
+};
+var renderDaemonRunData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Running"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["PID", data.daemon.pid],
+        ["State dir", data.daemon.state_dir],
+        ["Socket", data.daemon.socket_path]
+      ],
+      flags
+    )
+  ];
+};
+var renderDaemonStartData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Started"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["PID", data.daemon.pid],
+        ["WSS port", data.daemon.wss_port],
+        ["Started at", data.daemon.started_at]
+      ],
+      flags
+    )
+  ];
+};
+var renderDaemonStopData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Stopped"),
+    ...renderFields("Daemon", [["Method", data.daemon.method]], flags)
+  ];
+};
+var formatByteSize = (bytes) => {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${unit === 0 ? value : value.toFixed(1)} ${units[unit]}`;
+};
+var renderDaemonStatusData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Status"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["Version", data.daemon.version],
+        ["PID", data.daemon.pid],
+        ["Started at", data.daemon.started_at],
+        ["WSS port", data.daemon.wss_port],
+        ["Pinned keys", data.daemon.pinned_keys.length],
+        ["Sessions", data.daemon.session_count]
+      ],
+      flags
+    ),
+    "",
+    ...renderFields(
+      "Policy",
+      [
+        ["Default", data.policy.default],
+        ["Destructive", data.policy.destructive],
+        ["Overrides", data.policy.tools ? Object.keys(data.policy.tools).length : 0]
+      ],
+      flags
+    ),
+    "",
+    // The retention rows drop out entirely against a daemon that predates them (`renderFields`
+    // skips `undefined`), rather than printing "undefined" or an invented zero.
+    ...renderFields(
+      "Audit",
+      [
+        ["Path", data.audit.path],
+        ["Retention", data.audit.retention_days === void 0 ? void 0 : `${data.audit.retention_days} days`],
+        ["Files", data.audit.files],
+        ["Size", data.audit.bytes === void 0 ? void 0 : formatByteSize(data.audit.bytes)],
+        ["Failed writes", data.audit.failed_writes],
+        ["Failed prunes", data.audit.failed_prunes]
+      ],
+      flags
+    ),
+    // Version drift (issue #30) is the one thing here an operator has to act on, so it goes last
+    // — the line still on screen after the block scrolls — and in yellow, not a quiet field row.
+    ...data.warning ? ["", colors.yellow(`Warning: ${data.warning}`)] : []
+  ];
+};
+var renderDoctorData = (colors, data, flags) => {
+  return [
+    data.present ? colors.green("Appduct Present") : colors.yellow("Appduct Absent"),
+    ...renderFields(
+      "Artifact",
+      [
+        ["Path", data.artifact],
+        ["Platform", data.platform],
+        ["Format", data.format],
+        ["Present", data.present],
+        ["Signals", data.signals.length > 0 ? data.signals.join(", ") : "none"],
+        ["Assertion", data.assertion ? `${data.assertion.expected} (holds)` : void 0]
+      ],
+      flags
+    )
+  ];
+};
+var renderSuccessData = (colors, command, data, options) => {
+  const flags = options.flags;
+  switch (command) {
+    case "init":
+      return renderInitData(colors, data, flags);
+    case "keygen":
+      return renderKeygenData(colors, data, flags);
+    case "link":
+      return renderLinkData(colors, data, flags, options.qr);
+    case "ls":
+      return renderLsData(colors, data, options.now ?? /* @__PURE__ */ new Date());
+    case "tools":
+      return renderToolsData(colors, data, flags, options.full);
+    case "invoke":
+      return renderInvokeData(colors, data, flags);
+    case "revoke":
+      return renderRevokeData(colors, data);
+    case "daemon run":
+      return renderDaemonRunData(colors, data, flags);
+    case "daemon start":
+      return renderDaemonStartData(colors, data, flags);
+    case "daemon stop":
+      return renderDaemonStopData(colors, data, flags);
+    case "daemon status":
+      return renderDaemonStatusData(colors, data, flags);
+    case "doctor":
+      return renderDoctorData(colors, data, flags);
+    default:
+      return [colors.green("Command Complete"), formatJson(data, flags)];
+  }
+};
+var renderHumanError = (colors, error, flags, meta) => {
+  return [
+    colors.red("Command Failed"),
+    ...renderFields(
+      "Error",
+      [
+        ["Type", error.type],
+        ["Message", error.message],
+        ["Details", error.details]
+      ],
+      flags
+    ),
+    ...meta ? ["", ...renderMetaLines(meta)] : []
+  ].join("\n");
+};
+var renderResult = (result, options) => {
+  if (options.flags.json) {
+    return {
+      stdout: `${formatJson(result, options.flags)}
+`
+    };
+  }
+  const colors = pc.createColors(options.flags.color);
+  if (!result.ok) {
+    return {
+      stderr: `${renderHumanError(colors, result.error, options.flags, result.meta)}
+`
+    };
+  }
+  const lines = [
+    ...renderSuccessData(colors, options.command, result.data, options),
+    "",
+    ...renderMetaLines(result.meta)
+  ].filter((line, index, collection) => {
+    if (line !== "") {
+      return true;
+    }
+    return index > 0 && collection[index - 1] !== "" && index < collection.length - 1;
+  });
+  return {
+    stdout: `${lines.join("\n")}
+`
+  };
+};
+
+// src/cli/envelope.ts
+var createCommandMeta = (command, startedAt, finishedAt) => {
+  return {
+    command,
+    timestamp: finishedAt.toISOString(),
+    duration_ms: finishedAt.getTime() - startedAt.getTime()
+  };
+};
+var finalizeResult = (result, timing, flags) => {
+  if (!flags.verbose) {
+    return result;
+  }
+  return {
+    ...result,
+    meta: createCommandMeta(timing.command, timing.startedAt, timing.finishedAt)
+  };
+};
+
+// src/cli/runner.ts
+var writeRenderedOutput = (rendered, writers) => {
+  if (rendered.stdout) {
+    writers.stdout.write(rendered.stdout);
+  }
+  if (rendered.stderr) {
+    writers.stderr.write(rendered.stderr);
+  }
+};
+var executeHostedCommand = async (command, handler, env, reporter) => {
+  const startedAt = env.clock.now();
+  let renderedSuccess = false;
+  try {
+    const hosted = await handler();
+    const finishedAt = env.clock.now();
+    const finalized = finalizeResult(hosted.result, { command, startedAt, finishedAt }, env.flags);
+    const shouldRenderBootstrap = !reporter || reporter.kind === "plain";
+    if (shouldRenderBootstrap) {
+      writeRenderedOutput(
+        renderResult(finalized, { command, flags: env.flags, now: finishedAt }),
+        env
+      );
+      renderedSuccess = true;
+    }
+    let resolved = false;
+    const stop = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      hosted.stop();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+      await hosted.completion;
+    } finally {
+      resolved = true;
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      reporter?.dispose();
+    }
+    return 0;
+  } catch (error) {
+    reporter?.dispose();
+    const finishedAt = env.clock.now();
+    const cliError = toCliError(error);
+    const result = { ok: false, error: cliError };
+    const finalized = finalizeResult(result, { command, startedAt, finishedAt }, env.flags);
+    if (renderedSuccess && env.flags.json) {
+      env.stderr.write(`${formatJson(finalized, env.flags)}
+`);
+      return getExitCodeForError(error);
+    }
+    writeRenderedOutput(
+      renderResult(finalized, { command, flags: env.flags, now: finishedAt }),
+      env
+    );
+    return getExitCodeForError(error);
+  }
+};
+
+// src/cli/router.ts
+var commandName = (context) => {
+  return context.path.join(" ");
+};
+
+// src/cli/routes/daemon/run.ts
+var route = async (context) => {
+  const { stateDir, env } = context;
+  return executeHostedCommand(
+    commandName(context),
+    () => handleDaemonRunCommand({ stateDir, clock: env.clock }),
+    env
+  );
+};
+export {
+  route
+};