@annals/agent-mesh 0.16.2 → 0.16.4

package/dist/{chunk-GIEYJIVW.js → chunk-U32JDKSN.js}

@@ -8,6 +8,11 @@ import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+var DEFAULT_RUNTIME_CONFIG = {
+  max_active_requests: 100,
+  queue_wait_timeout_ms: 10 * 6e4,
+  queue_max_length: 1e3
+};
 var CONFIG_DIR = join(homedir(), ".agent-mesh");
 var CONFIG_FILE = join(CONFIG_DIR, "config.json");
 var PIDS_DIR = join(CONFIG_DIR, "pids");
@@ -35,6 +40,34 @@ function updateConfig(partial) {
   const existing = loadConfig();
   saveConfig({ ...existing, ...partial });
 }
+function parsePositiveInt(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return void 0;
+  const n = Math.floor(raw);
+  return n > 0 ? n : void 0;
+}
+function resolveRuntimeConfig(config) {
+  const runtime = (config || loadConfig()).runtime || {};
+  return {
+    max_active_requests: parsePositiveInt(runtime.max_active_requests) ?? DEFAULT_RUNTIME_CONFIG.max_active_requests,
+    queue_wait_timeout_ms: parsePositiveInt(runtime.queue_wait_timeout_ms) ?? DEFAULT_RUNTIME_CONFIG.queue_wait_timeout_ms,
+    queue_max_length: parsePositiveInt(runtime.queue_max_length) ?? DEFAULT_RUNTIME_CONFIG.queue_max_length
+  };
+}
+function getRuntimeConfig() {
+  return resolveRuntimeConfig(loadConfig());
+}
+function updateRuntimeConfig(partial) {
+  const config = loadConfig();
+  config.runtime = { ...config.runtime || {}, ...partial };
+  saveConfig(config);
+  return resolveRuntimeConfig(config);
+}
+function resetRuntimeConfig() {
+  const config = loadConfig();
+  config.runtime = { ...DEFAULT_RUNTIME_CONFIG };
+  saveConfig(config);
+  return resolveRuntimeConfig(config);
+}
 function getConfigPath() {
   return CONFIG_FILE;
 }
@@ -908,8 +941,13 @@ function registerListCommand(program) {
 }
 
 export {
+  DEFAULT_RUNTIME_CONFIG,
   loadConfig,
   updateConfig,
+  resolveRuntimeConfig,
+  getRuntimeConfig,
+  updateRuntimeConfig,
+  resetRuntimeConfig,
   getConfigPath,
   getAgent,
   addAgent,

package/dist/index.js

@@ -5,6 +5,7 @@ import {
 } from "./chunk-W24WCWEC.js";
 import {
   BOLD,
+  DEFAULT_RUNTIME_CONFIG,
   GRAY,
   GREEN,
   RESET,
@@ -15,6 +16,7 @@ import {
   getAgentWorkspaceDir,
   getConfigPath,
   getLogPath,
+  getRuntimeConfig,
   isProcessAlive,
   listAgents,
   loadConfig,
@@ -23,12 +25,15 @@ import {
   removeAgent,
   removePid,
   renderTable,
+  resetRuntimeConfig,
+  resolveRuntimeConfig,
   spawnBackground,
   stopProcess,
   uniqueSlug,
   updateConfig,
+  updateRuntimeConfig,
   writePid
-} from "./chunk-GIEYJIVW.js";
+} from "./chunk-U32JDKSN.js";
 
 // src/index.ts
 import { createRequire } from "module";
@@ -269,6 +274,351 @@ var SessionPool = class {
   }
 };
 
+// src/utils/local-runtime-queue.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_LOCK_STALE_MS = 3e4;
+var DEFAULT_LOCK_WAIT_MS = 1e4;
+var DEFAULT_LOCK_RETRY_MS = 25;
+var DEFAULT_POLL_INTERVAL_MS = 100;
+var DEFAULT_LEASE_TTL_MS = 15e3;
+var DEFAULT_LEASE_HEARTBEAT_MS = 5e3;
+var LocalRuntimeQueueError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LocalRuntimeQueueError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toRequestKey(input) {
+  return `${input.agentId}:${input.sessionId}:${input.requestId}`;
+}
+function toRuntimeQueueConfig(config) {
+  return {
+    maxActiveRequests: config.max_active_requests,
+    queueWaitTimeoutMs: config.queue_wait_timeout_ms,
+    queueMaxLength: config.queue_max_length
+  };
+}
+function fromRuntimeQueueConfig(config) {
+  return {
+    max_active_requests: config.maxActiveRequests,
+    queue_wait_timeout_ms: config.queueWaitTimeoutMs,
+    queue_max_length: config.queueMaxLength
+  };
+}
+var LocalRuntimeQueue = class {
+  runtimeRoot;
+  statePath;
+  lockPath;
+  config;
+  lockStaleMs;
+  lockWaitMs;
+  lockRetryMs;
+  pollIntervalMs;
+  leaseTtlMs;
+  leaseHeartbeatMs;
+  constructor(config, opts = {}) {
+    this.config = config;
+    const baseDir = opts.baseDir || join(homedir(), ".agent-mesh");
+    this.runtimeRoot = join(baseDir, "runtime");
+    this.statePath = join(this.runtimeRoot, "queue-state.json");
+    this.lockPath = join(this.runtimeRoot, "queue.lock");
+    this.lockStaleMs = opts.lockStaleMs ?? DEFAULT_LOCK_STALE_MS;
+    this.lockWaitMs = opts.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;
+    this.lockRetryMs = opts.lockRetryMs ?? DEFAULT_LOCK_RETRY_MS;
+    this.pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.leaseTtlMs = opts.leaseTtlMs ?? DEFAULT_LEASE_TTL_MS;
+    this.leaseHeartbeatMs = opts.leaseHeartbeatMs ?? DEFAULT_LEASE_HEARTBEAT_MS;
+    this.ensureRuntimeDir();
+  }
+  async acquire(input, opts = {}) {
+    const requestKey = toRequestKey(input);
+    const queueId = crypto.randomUUID();
+    const deadlineAt = Date.now() + this.config.queueWaitTimeoutMs;
+    const signal = opts.signal;
+    if (signal?.aborted) {
+      throw new LocalRuntimeQueueError("queue_aborted", "Queue wait aborted");
+    }
+    await this.withLock(async (state) => {
+      const now = Date.now();
+      this.cleanupLockedState(state, now);
+      if (state.active[requestKey]) {
+        throw new LocalRuntimeQueueError("queue_cancelled", "Request is already active");
+      }
+      if (state.queue.some((entry) => entry.request_key === requestKey)) {
+        throw new LocalRuntimeQueueError("queue_cancelled", "Request is already queued");
+      }
+      if (state.queue.length >= this.config.queueMaxLength) {
+        throw new LocalRuntimeQueueError("queue_full", `Local queue full (${this.config.queueMaxLength})`);
+      }
+      state.queue.push({
+        queue_id: queueId,
+        request_key: requestKey,
+        agent_id: input.agentId,
+        session_id: input.sessionId,
+        request_id: input.requestId,
+        pid: input.pid,
+        enqueued_at: now,
+        deadline_at: deadlineAt
+      });
+    });
+    while (true) {
+      if (signal?.aborted) {
+        await this.removeQueuedByKey(requestKey);
+        throw new LocalRuntimeQueueError("queue_aborted", "Queue wait aborted");
+      }
+      let promotedLease = null;
+      let queuePosition = -1;
+      let activeCount = 0;
+      await this.withLock(async (state) => {
+        const now = Date.now();
+        this.cleanupLockedState(state, now);
+        activeCount = Object.keys(state.active).length;
+        queuePosition = state.queue.findIndex((entry2) => entry2.request_key === requestKey);
+        if (queuePosition === -1) {
+          if (state.active[requestKey]) {
+            promotedLease = state.active[requestKey];
+          }
+          return;
+        }
+        const entry = state.queue[queuePosition];
+        if (entry.deadline_at <= now) {
+          state.queue.splice(queuePosition, 1);
+          throw new LocalRuntimeQueueError("queue_timeout", `Local queue wait timeout (${Math.floor(this.config.queueWaitTimeoutMs / 1e3)}s)`);
+        }
+        if (queuePosition === 0 && activeCount < this.config.maxActiveRequests) {
+          state.queue.shift();
+          const lease = {
+            lease_id: crypto.randomUUID(),
+            request_key: requestKey,
+            agent_id: input.agentId,
+            session_id: input.sessionId,
+            request_id: input.requestId,
+            pid: input.pid,
+            acquired_at: now,
+            lease_expires_at: now + this.leaseTtlMs
+          };
+          state.active[requestKey] = lease;
+          promotedLease = lease;
+          activeCount = Object.keys(state.active).length;
+        }
+      });
+      if (promotedLease) {
+        if (queuePosition > 0) {
+          log.debug(`Queue promoted after race: request=${requestKey} active=${activeCount}/${this.config.maxActiveRequests}`);
+        }
+        return this.createLease(promotedLease);
+      }
+      if (queuePosition === -1) {
+        if (Date.now() >= deadlineAt) {
+          throw new LocalRuntimeQueueError("queue_timeout", `Local queue wait timeout (${Math.floor(this.config.queueWaitTimeoutMs / 1e3)}s)`);
+        }
+        throw new LocalRuntimeQueueError("queue_cancelled", "Request was removed from local queue");
+      }
+      await sleep(this.pollIntervalMs);
+    }
+  }
+  async cancelQueued(input) {
+    return this.removeQueuedByKey(toRequestKey(input));
+  }
+  async snapshot() {
+    let active = 0;
+    let queued = 0;
+    await this.withLock(async (state) => {
+      this.cleanupLockedState(state, Date.now());
+      active = Object.keys(state.active).length;
+      queued = state.queue.length;
+    });
+    return {
+      active,
+      queued,
+      config: { ...this.config }
+    };
+  }
+  async removeQueuedByKey(requestKey) {
+    let removed = false;
+    await this.withLock(async (state) => {
+      const idx = state.queue.findIndex((entry) => entry.request_key === requestKey);
+      if (idx >= 0) {
+        state.queue.splice(idx, 1);
+        removed = true;
+      }
+    });
+    return removed;
+  }
+  createLease(activeLease) {
+    let released = false;
+    let heartbeatTimer = null;
+    const stopHeartbeat = () => {
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+    };
+    return {
+      leaseId: activeLease.lease_id,
+      requestKey: activeLease.request_key,
+      release: async (_reason) => {
+        if (released) return;
+        released = true;
+        stopHeartbeat();
+        await this.withLock(async (state) => {
+          const current = state.active[activeLease.request_key];
+          if (current?.lease_id === activeLease.lease_id) {
+            delete state.active[activeLease.request_key];
+          }
+        });
+      },
+      startHeartbeat: () => {
+        if (released || heartbeatTimer) {
+          return stopHeartbeat;
+        }
+        heartbeatTimer = setInterval(() => {
+          void this.extendLease(activeLease.request_key, activeLease.lease_id);
+        }, this.leaseHeartbeatMs);
+        heartbeatTimer.unref?.();
+        return stopHeartbeat;
+      }
+    };
+  }
+  async extendLease(requestKey, leaseId) {
+    try {
+      await this.withLock(async (state) => {
+        const lease = state.active[requestKey];
+        if (lease && lease.lease_id === leaseId) {
+          lease.lease_expires_at = Date.now() + this.leaseTtlMs;
+        }
+      });
+    } catch (err) {
+      log.debug(`Failed to extend local queue lease: ${err}`);
+    }
+  }
+  ensureRuntimeDir() {
+    if (!existsSync(this.runtimeRoot)) {
+      mkdirSync(this.runtimeRoot, { recursive: true, mode: 448 });
+    }
+  }
+  defaultState() {
+    return {
+      version: 1,
+      config: fromRuntimeQueueConfig(this.config),
+      active: {},
+      queue: [],
+      updated_at: Date.now()
+    };
+  }
+  readState() {
+    try {
+      const raw = readFileSync(this.statePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.version === 1 && parsed.active && Array.isArray(parsed.queue)) {
+        return {
+          version: 1,
+          config: fromRuntimeQueueConfig(this.config),
+          active: parsed.active,
+          queue: parsed.queue,
+          updated_at: typeof parsed.updated_at === "number" ? parsed.updated_at : Date.now()
+        };
+      }
+    } catch {
+    }
+    return this.defaultState();
+  }
+  writeState(state) {
+    state.config = fromRuntimeQueueConfig(this.config);
+    state.updated_at = Date.now();
+    const tmpPath = `${this.statePath}.${process.pid}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+    renameSync(tmpPath, this.statePath);
+  }
+  cleanupLockedState(state, now) {
+    for (const [key, lease] of Object.entries(state.active)) {
+      const expired = lease.lease_expires_at <= now;
+      const deadPid = !isProcessAlive2(lease.pid);
+      if (expired || deadPid) {
+        delete state.active[key];
+      }
+    }
+    state.queue = state.queue.filter((entry) => {
+      if (entry.deadline_at <= now) return false;
+      if (!isProcessAlive2(entry.pid)) return false;
+      return true;
+    });
+  }
+  async withLock(fn) {
+    this.ensureRuntimeDir();
+    const acquiredAt = Date.now();
+    while (true) {
+      try {
+        mkdirSync(this.lockPath, { mode: 448 });
+        break;
+      } catch (err) {
+        const e = err;
+        if (e.code !== "EEXIST") {
+          throw err;
+        }
+        try {
+          const st = statSync(this.lockPath);
+          if (Date.now() - st.mtimeMs > this.lockStaleMs) {
+            rmSync(this.lockPath, { recursive: true, force: true });
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        if (Date.now() - acquiredAt >= this.lockWaitMs) {
+          throw new Error("Timed out waiting for local runtime queue lock");
+        }
+        await sleep(this.lockRetryMs);
+      }
+    }
+    try {
+      const state = this.readState();
+      try {
+        const result = await fn(state);
+        this.writeState(state);
+        return result;
+      } catch (err) {
+        try {
+          this.writeState(state);
+        } catch {
+        }
+        throw err;
+      }
+    } finally {
+      try {
+        rmSync(this.lockPath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+};
+function createLocalRuntimeQueue(config) {
+  return new LocalRuntimeQueue(toRuntimeQueueConfig(config));
+}
+
 // src/bridge/manager.ts
 var DUPLICATE_REQUEST_TTL_MS = 10 * 6e4;
 var SESSION_SWEEP_INTERVAL_MS = 6e4;
@@ -299,11 +649,15 @@ var BridgeManager = class {
   requestTracker = /* @__PURE__ */ new Map();
   /** Last activity timestamp per session for idle cleanup */
   sessionLastSeenAt = /* @__PURE__ */ new Map();
+  /** Request lifecycle state for local queueing (queued/running) */
+  requestDispatches = /* @__PURE__ */ new Map();
   cleanupTimer = null;
+  runtimeQueue;
   constructor(opts) {
     this.wsClient = opts.wsClient;
     this.adapter = opts.adapter;
     this.adapterConfig = opts.adapterConfig;
+    this.runtimeQueue = opts.runtimeQueue || createLocalRuntimeQueue(resolveRuntimeConfig(loadConfig()));
   }
   start() {
     this.wsClient.onMessage((msg) => this.handleWorkerMessage(msg));
@@ -325,6 +679,7 @@ var BridgeManager = class {
     this.activeRequests.clear();
     this.wiredSessions.clear();
     this.sessionLastSeenAt.clear();
+    this.cleanupRequestDispatches("shutdown");
     log.info("Bridge manager stopped");
   }
   /**
@@ -340,6 +695,7 @@ var BridgeManager = class {
     this.activeRequests.clear();
     this.wiredSessions.clear();
     this.sessionLastSeenAt.clear();
+    this.cleanupRequestDispatches("shutdown");
     log.info("Bridge manager reconnected");
   }
   get sessionCount() {
@@ -360,7 +716,7 @@ var BridgeManager = class {
     }
   }
   handleMessage(msg) {
-    const { session_id, request_id, content, attachments, upload_url, upload_token, client_id } = msg;
+    const { session_id, request_id } = msg;
     const now = Date.now();
     this.pruneExpiredRequests(now);
     this.pruneIdleSessions(now);
@@ -399,14 +755,78 @@ var BridgeManager = class {
       this.wireSession(handle, session_id, requestRef);
       this.wiredSessions.add(session_id);
     }
-    const uploadCredentials = upload_url && upload_token ? { uploadUrl: upload_url, uploadToken: upload_token } : void 0;
+    const requestKey = this.requestKey(session_id, request_id);
+    const queueInput = {
+      agentId: this.adapterConfig.agentId || "unknown-agent",
+      sessionId: session_id,
+      requestId: request_id,
+      pid: process.pid
+    };
+    this.requestDispatches.set(requestKey, {
+      queueInput,
+      abortController: new AbortController(),
+      cancelled: false,
+      cleaned: false
+    });
+    void this.dispatchWithLocalQueue({
+      msg,
+      handle,
+      requestKey
+    });
+  }
+  async dispatchWithLocalQueue(opts) {
+    const { msg, handle, requestKey } = opts;
+    const { session_id, request_id, content, attachments, upload_url, upload_token, client_id } = msg;
+    const state = this.requestDispatches.get(requestKey);
+    if (!state) return;
     try {
-      handle.send(content, attachments, uploadCredentials, client_id);
-      this.sessionLastSeenAt.set(session_id, Date.now());
+      const lease = await this.runtimeQueue.acquire(state.queueInput, {
+        signal: state.abortController.signal
+      });
+      if (state.cleaned) {
+        await lease.release("shutdown");
+        return;
+      }
+      state.lease = lease;
+      state.stopLeaseHeartbeat = lease.startHeartbeat();
+      if (state.cancelled) {
+        this.trackRequest(session_id, request_id, "cancelled");
+        this.sendError(session_id, request_id, BridgeErrorCode.SESSION_NOT_FOUND, "Request cancelled before execution");
+        await this.releaseRequestLease(session_id, request_id, "cancel");
+        return;
+      }
+      const uploadCredentials = upload_url && upload_token ? { uploadUrl: upload_url, uploadToken: upload_token } : void 0;
+      try {
+        handle.send(content, attachments, uploadCredentials, client_id);
+        this.sessionLastSeenAt.set(session_id, Date.now());
+      } catch (err) {
+        log.error(`Failed to send to adapter: ${err}`);
+        this.trackRequest(session_id, request_id, "error");
+        this.sendError(session_id, request_id, BridgeErrorCode.ADAPTER_CRASH, `Adapter send failed: ${err}`);
+        await this.releaseRequestLease(session_id, request_id, "error");
+      }
     } catch (err) {
-      log.error(`Failed to send to adapter: ${err}`);
+      if (state.cleaned) return;
+      if (state.cancelled && err instanceof LocalRuntimeQueueError && (err.code === "queue_aborted" || err.code === "queue_cancelled")) {
+        this.sendError(session_id, request_id, BridgeErrorCode.SESSION_NOT_FOUND, "Request cancelled before execution");
+        this.cleanupRequestDispatchState(requestKey);
+        return;
+      }
+      if (err instanceof LocalRuntimeQueueError && (err.code === "queue_full" || err.code === "queue_timeout")) {
+        log.warn(`Local queue rejected request: ${err.message}`);
+        this.trackRequest(session_id, request_id, "error");
+        this.sendError(session_id, request_id, BridgeErrorCode.AGENT_BUSY, err.message);
+        this.cleanupRequestDispatchState(requestKey);
+        return;
+      }
+      if (err instanceof LocalRuntimeQueueError && (err.code === "queue_aborted" || err.code === "queue_cancelled")) {
+        this.cleanupRequestDispatchState(requestKey);
+        return;
+      }
+      log.error(`Local queue error: ${err}`);
       this.trackRequest(session_id, request_id, "error");
-      this.sendError(session_id, request_id, BridgeErrorCode.ADAPTER_CRASH, `Adapter send failed: ${err}`);
+      this.sendError(session_id, request_id, BridgeErrorCode.INTERNAL_ERROR, "Local runtime queue failure");
+      this.cleanupRequestDispatchState(requestKey);
     }
   }
   wireSession(handle, sessionId, requestRef) {
@@ -436,6 +856,7 @@ var BridgeManager = class {
       this.sessionLastSeenAt.set(sessionId, Date.now());
     });
     handle.onDone((attachments) => {
+      void this.releaseRequestLease(sessionId, requestRef.requestId, "done");
       const done = {
         type: "done",
         session_id: sessionId,
@@ -452,6 +873,7 @@ var BridgeManager = class {
     });
     handle.onError((err) => {
       log.error(`Adapter error (session=${sessionId.slice(0, 8)}...): ${err.message}`);
+      void this.releaseRequestLease(sessionId, requestRef.requestId, "error");
       this.trackRequest(sessionId, requestRef.requestId, "error");
       this.sendError(sessionId, requestRef.requestId, BridgeErrorCode.ADAPTER_CRASH, err.message);
       this.sessionLastSeenAt.set(sessionId, Date.now());
@@ -461,9 +883,23 @@ var BridgeManager = class {
     const { session_id, request_id } = msg;
     log.info(`Cancel received: session=${session_id.slice(0, 8)}...`);
     this.trackRequest(session_id, request_id, "cancelled");
+    const requestKey = this.requestKey(session_id, request_id);
+    const state = this.requestDispatches.get(requestKey);
+    if (state && !state.lease) {
+      state.cancelled = true;
+      state.abortController.abort();
+      void this.runtimeQueue.cancelQueued(state.queueInput).catch((err) => {
+        log.warn(`Failed to cancel local queue entry: ${err}`);
+      });
+      return;
+    }
     this.destroySession(session_id, "cancel_signal");
   }
   destroySession(sessionId, reason) {
+    const requestRef = this.activeRequests.get(sessionId);
+    if (requestRef) {
+      void this.releaseRequestLease(sessionId, requestRef.requestId, reason === "cancel_signal" ? "cancel" : "shutdown");
+    }
     const handle = this.pool.get(sessionId);
     if (!handle) {
       this.sessionLastSeenAt.delete(sessionId);
@@ -532,6 +968,74 @@ var BridgeManager = class {
   requestKey(sessionId, requestId) {
     return `${sessionId}:${requestId}`;
   }
+  async releaseRequestLease(sessionId, requestId, reason) {
+    const key = this.requestKey(sessionId, requestId);
+    const state = this.requestDispatches.get(key);
+    if (!state || state.cleaned) {
+      return;
+    }
+    state.cleaned = true;
+    if (state.stopLeaseHeartbeat) {
+      try {
+        state.stopLeaseHeartbeat();
+      } catch {
+      }
+      state.stopLeaseHeartbeat = void 0;
+    }
+    if (state.lease) {
+      try {
+        await state.lease.release(reason);
+      } catch (err) {
+        log.warn(`Failed to release local queue lease: ${err}`);
+      }
+    } else {
+      state.abortController.abort();
+      try {
+        await this.runtimeQueue.cancelQueued(state.queueInput);
+      } catch (err) {
+        log.warn(`Failed to remove local queue entry: ${err}`);
+      }
+    }
+    this.requestDispatches.delete(key);
+  }
+  cleanupRequestDispatchState(requestKey) {
+    const state = this.requestDispatches.get(requestKey);
+    if (!state) return;
+    state.cleaned = true;
+    if (state.stopLeaseHeartbeat) {
+      try {
+        state.stopLeaseHeartbeat();
+      } catch {
+      }
+      state.stopLeaseHeartbeat = void 0;
+    }
+    this.requestDispatches.delete(requestKey);
+  }
+  cleanupRequestDispatches(reason) {
+    for (const [requestKey, state] of Array.from(this.requestDispatches.entries())) {
+      if (state.cleaned) continue;
+      state.cleaned = true;
+      state.cancelled = true;
+      state.abortController.abort();
+      if (state.stopLeaseHeartbeat) {
+        try {
+          state.stopLeaseHeartbeat();
+        } catch {
+        }
+        state.stopLeaseHeartbeat = void 0;
+      }
+      if (state.lease) {
+        void state.lease.release(reason).catch((err) => {
+          log.warn(`Failed to release local queue lease during cleanup: ${err}`);
+        });
+      } else {
+        void this.runtimeQueue.cancelQueued(state.queueInput).catch((err) => {
+          log.warn(`Failed to cancel queued request during cleanup: ${err}`);
+        });
+      }
+      this.requestDispatches.delete(requestKey);
+    }
+  }
   trackRequest(sessionId, requestId, status) {
     this.requestTracker.set(this.requestKey(sessionId, requestId), {
       status,
@@ -555,8 +1059,8 @@ var AgentAdapter = class {
 };
 
 // src/utils/client-workspace.ts
-import { mkdirSync, readdirSync, symlinkSync, existsSync, lstatSync } from "fs";
-import { join, relative } from "path";
+import { mkdirSync as mkdirSync2, readdirSync, symlinkSync, existsSync as existsSync2, lstatSync } from "fs";
+import { join as join2, relative } from "path";
 var SYMLINK_ALLOW = /* @__PURE__ */ new Set([
   "CLAUDE.md",
   ".claude",
@@ -585,19 +1089,19 @@ function shouldInclude(name) {
   return false;
 }
 function createClientWorkspace(projectPath, clientId) {
-  const wsDir = join(projectPath, ".bridge-clients", clientId);
-  const isNew = !existsSync(wsDir);
-  mkdirSync(wsDir, { recursive: true });
+  const wsDir = join2(projectPath, ".bridge-clients", clientId);
+  const isNew = !existsSync2(wsDir);
+  mkdirSync2(wsDir, { recursive: true });
   const entries = readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (!shouldInclude(entry.name)) continue;
-    const link = join(wsDir, entry.name);
+    const link = join2(wsDir, entry.name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join(projectPath, entry.name);
+    const target = join2(projectPath, entry.name);
     const relTarget = relative(wsDir, target);
     try {
       symlinkSync(relTarget, link);
@@ -613,7 +1117,7 @@ function createClientWorkspace(projectPath, clientId) {
 
 // src/utils/auto-upload.ts
 import { readdir, readFile, stat } from "fs/promises";
-import { join as join2, relative as relative2 } from "path";
+import { join as join3, relative as relative2 } from "path";
 var MAX_AUTO_UPLOAD_FILES = 50;
 var MAX_AUTO_UPLOAD_FILE_SIZE = 10 * 1024 * 1024;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -656,7 +1160,7 @@ async function collectRealFiles(dir, maxFiles = Infinity) {
     for (const entry of entries) {
       if (files.length >= maxFiles) return;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = join2(d, entry.name);
+      const fullPath = join3(d, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         await walk(fullPath);
@@ -972,7 +1476,7 @@ import { spawn } from "child_process";
 
 // src/utils/sandbox.ts
 import { execSync } from "child_process";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var SRT_PACKAGE = "@anthropic-ai/sandbox-runtime";
 var SENSITIVE_PATHS = [
   // SSH & crypto keys
@@ -1037,7 +1541,7 @@ var sandboxInitialized = false;
 async function importSandboxManager() {
   try {
     const globalRoot = execSync("npm root -g", { encoding: "utf-8" }).trim();
-    const srtPath = join3(globalRoot, "@anthropic-ai/sandbox-runtime/dist/index.js");
+    const srtPath = join4(globalRoot, "@anthropic-ai/sandbox-runtime/dist/index.js");
     const mod = await import(srtPath);
     return mod.SandboxManager;
   } catch {
@@ -1202,18 +1706,18 @@ async function spawnAgent(command, args, options) {
 
 // src/adapters/claude.ts
 import { createInterface } from "readline";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 
 // src/utils/which.ts
 import { execFile } from "child_process";
 import { access, constants } from "fs/promises";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 var ALLOWED_COMMANDS = /^[a-zA-Z0-9._-]+$/;
 var FALLBACK_PATHS = {
   claude: [
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
-    `${homedir()}/.local/bin/claude`
+    `${homedir2()}/.local/bin/claude`
   ]
 };
 async function resolveFallbackPath(command) {
@@ -1244,10 +1748,10 @@ function which(command) {
 
 // src/adapters/claude.ts
 import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { join as join4, relative as relative3, basename } from "path";
+import { join as join5, relative as relative3, basename } from "path";
 var DEFAULT_IDLE_TIMEOUT = 30 * 60 * 1e3;
 var MIN_IDLE_TIMEOUT = 60 * 1e3;
-var HOME_DIR = homedir2();
+var HOME_DIR = homedir3();
 var CLAUDE_RUNTIME_ALLOW_WRITE_PATHS = [
   `${HOME_DIR}/.claude`,
   `${HOME_DIR}/.claude.json`,
@@ -1331,7 +1835,7 @@ var ClaudeSession = class {
     await mkdir(workspaceRoot, { recursive: true });
     for (const att of attachments) {
       const safeName = basename(att.name).replace(/[^a-zA-Z0-9._-]/g, "_") || "attachment";
-      const destPath = join4(workspaceRoot, safeName);
+      const destPath = join5(workspaceRoot, safeName);
       try {
         const res = await fetch(att.url);
         if (!res.ok) {
@@ -1743,7 +2247,7 @@ function logWorkspaceHint(slug, projectPath) {
   console.log(`  ${GRAY}Workspace: ${RESET}${projectPath}`);
   console.log(`  ${GRAY}Put CLAUDE.md (role instructions) and .claude/skills/ here.${RESET}`);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function createAdapter(type, config) {
@@ -1820,14 +2324,14 @@ function registerConnectCommand(program2) {
           type = ticketData.agent_type;
         } else {
           const pid = spawnBackground(slug, entry, config.token);
-          await sleep(500);
+          await sleep2(500);
           if (isProcessAlive(pid)) {
             console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${slug}${RESET} started (PID: ${pid})`);
           } else {
             log.error(`Failed to start. Check logs: ${getLogPath(slug)}`);
             process.exit(1);
           }
-          const { ListTUI } = await import("./list-6CHWMM3O.js");
+          const { ListTUI } = await import("./list-KMJ463VL.js");
           const tui = new ListTUI();
           await tui.run();
           return;
@@ -2166,7 +2670,7 @@ function registerStatusCommand(program2) {
 }
 
 // src/commands/start.ts
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function registerStartCommand(program2) {
@@ -2201,7 +2705,7 @@ function registerStartCommand(program2) {
         continue;
       }
       const newPid = spawnBackground(t, entry, config.token);
-      await sleep2(500);
+      await sleep3(500);
       if (isProcessAlive(newPid)) {
         console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${t}${RESET} started (PID: ${newPid})`);
         console.log(`    Logs: ${GRAY}${getLogPath(t)}${RESET}`);
@@ -2261,7 +2765,7 @@ function registerStopCommand(program2) {
 }
 
 // src/commands/restart.ts
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function registerRestartCommand(program2) {
@@ -2290,10 +2794,10 @@ function registerRestartCommand(program2) {
     let restarted = 0;
     for (const t of targets) {
       await stopProcess(t);
-      await sleep3(1e3);
+      await sleep4(1e3);
       const entry = agents[t];
       const newPid = spawnBackground(t, entry, config.token);
-      await sleep3(500);
+      await sleep4(500);
       if (isProcessAlive(newPid)) {
         console.log(`  ${GREEN}\u2713${RESET} ${BOLD}${t}${RESET} restarted (PID: ${newPid})`);
         console.log(`    Logs: ${GRAY}${getLogPath(t)}${RESET}`);
@@ -2312,7 +2816,7 @@ function registerRestartCommand(program2) {
 
 // src/commands/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 function registerLogsCommand(program2) {
   program2.command("logs <name>").description("View agent logs (follows in real-time)").option("-n, --lines <number>", "Number of lines to show", "50").action((name, opts) => {
     const entry = getAgent(name);
@@ -2321,7 +2825,7 @@ function registerLogsCommand(program2) {
       process.exit(1);
     }
     const logPath = getLogPath(name);
-    if (!existsSync2(logPath)) {
+    if (!existsSync3(logPath)) {
       log.error(`No log file found for "${name}". Has this agent been started before?`);
       process.exit(1);
     }
@@ -2402,14 +2906,14 @@ function registerOpenCommand(program2) {
 }
 
 // src/commands/install.ts
-import { writeFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 import { execSync as execSync2 } from "child_process";
 var LABEL = "com.agents-hot.agent-mesh";
-var PLIST_DIR = join5(homedir3(), "Library", "LaunchAgents");
-var PLIST_PATH = join5(PLIST_DIR, `${LABEL}.plist`);
-var LOG_PATH = join5(homedir3(), ".agent-mesh", "logs", "launchd.log");
+var PLIST_DIR = join6(homedir4(), "Library", "LaunchAgents");
+var PLIST_PATH = join6(PLIST_DIR, `${LABEL}.plist`);
+var LOG_PATH = join6(homedir4(), ".agent-mesh", "logs", "launchd.log");
 function detectPaths() {
   return {
     node: process.execPath,
@@ -2442,7 +2946,7 @@ function generatePlist(nodePath, scriptPath) {
   <string>${escapeXml(LOG_PATH)}</string>
 
   <key>WorkingDirectory</key>
-  <string>${escapeXml(homedir3())}</string>
+  <string>${escapeXml(homedir4())}</string>
 </dict>
 </plist>
 `;
@@ -2456,7 +2960,7 @@ function registerInstallCommand(program2) {
       log.error("LaunchAgent is macOS only. On Linux, use systemd user service instead.");
       process.exit(1);
     }
-    if (existsSync3(PLIST_PATH) && !opts.force) {
+    if (existsSync4(PLIST_PATH) && !opts.force) {
       console.log(`
   ${YELLOW}\u2298${RESET} LaunchAgent already installed at:`);
       console.log(`    ${GRAY}${PLIST_PATH}${RESET}`);
@@ -2466,17 +2970,17 @@ function registerInstallCommand(program2) {
       return;
     }
     const { node, script } = detectPaths();
-    if (!existsSync3(PLIST_DIR)) {
-      mkdirSync2(PLIST_DIR, { recursive: true });
+    if (!existsSync4(PLIST_DIR)) {
+      mkdirSync3(PLIST_DIR, { recursive: true });
     }
-    if (existsSync3(PLIST_PATH)) {
+    if (existsSync4(PLIST_PATH)) {
       try {
         execSync2(`launchctl bootout gui/$(id -u) "${PLIST_PATH}" 2>/dev/null`, { stdio: "ignore" });
       } catch {
       }
     }
     const plist = generatePlist(node, script);
-    writeFileSync(PLIST_PATH, plist, { encoding: "utf-8" });
+    writeFileSync2(PLIST_PATH, plist, { encoding: "utf-8" });
     try {
       execSync2(`launchctl bootstrap gui/$(id -u) "${PLIST_PATH}"`, { stdio: "pipe" });
     } catch {
@@ -2502,19 +3006,19 @@ function registerInstallCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync4, unlinkSync as unlinkSync2 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
 import { execSync as execSync3 } from "child_process";
 var LABEL2 = "com.agents-hot.agent-mesh";
-var PLIST_PATH2 = join6(homedir4(), "Library", "LaunchAgents", `${LABEL2}.plist`);
+var PLIST_PATH2 = join7(homedir5(), "Library", "LaunchAgents", `${LABEL2}.plist`);
 function registerUninstallCommand(program2) {
   program2.command("uninstall").description("Remove macOS LaunchAgent (agents will no longer auto-start)").action(async () => {
     if (process.platform !== "darwin") {
       log.error("LaunchAgent is macOS only.");
       process.exit(1);
     }
-    if (!existsSync4(PLIST_PATH2)) {
+    if (!existsSync5(PLIST_PATH2)) {
       console.log(`
   ${YELLOW}\u2298${RESET} No LaunchAgent found at ${GRAY}${PLIST_PATH2}${RESET}
 `);
@@ -2899,7 +3403,7 @@ function parseSseChunk(raw, carry) {
 
 // src/commands/chat.ts
 var DEFAULT_BASE_URL3 = "https://agents.hot";
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function asyncChat(opts) {
@@ -2931,7 +3435,7 @@ async function asyncChat(opts) {
   const startTime = Date.now();
   while (Date.now() - startTime < maxWait) {
     if (opts.signal?.aborted) throw new Error("Aborted");
-    await sleep4(pollInterval);
+    await sleep5(pollInterval);
     const pollRes = await fetch(`${opts.baseUrl}/api/agents/${opts.agentId}/task-status/${request_id}`, {
       headers: { Authorization: `Bearer ${opts.token}` },
       signal: opts.signal
@@ -3152,12 +3656,12 @@ function registerChatCommand(program2) {
 }
 
 // src/commands/skills.ts
-import { readFile as readFile4, writeFile as writeFile3, readdir as readdir2, mkdir as mkdir2, rm } from "fs/promises";
-import { join as join8, resolve, relative as relative4 } from "path";
+import { readFile as readFile4, writeFile as writeFile3, readdir as readdir2, mkdir as mkdir2, rm, symlink, unlink } from "fs/promises";
+import { join as join9, resolve, relative as relative4 } from "path";
 
 // src/utils/skill-parser.ts
 import { readFile as readFile3, writeFile as writeFile2, stat as stat2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function parseSkillMd(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -3217,7 +3721,7 @@ function parseSkillMd(raw) {
   return { frontmatter, content };
 }
 async function loadSkillManifest(dir) {
-  const skillMdPath = join7(dir, "SKILL.md");
+  const skillMdPath = join8(dir, "SKILL.md");
   try {
     const raw = await readFile3(skillMdPath, "utf-8");
     const { frontmatter } = parseSkillMd(raw);
@@ -3469,15 +3973,22 @@ function skillApiPath(authorLogin, slug) {
 }
 async function resolveSkillsRootAsync(pathArg) {
   const projectRoot = pathArg ? resolve(pathArg) : process.cwd();
-  const claudeDir = join8(projectRoot, ".claude", "skills");
-  if (await pathExists(claudeDir)) {
-    return { projectRoot, skillsDir: claudeDir, convention: "claude" };
+  const skillsDir = join9(projectRoot, ".agents", "skills");
+  const claudeSkillsDir = join9(projectRoot, ".claude", "skills");
+  return { projectRoot, skillsDir, claudeSkillsDir };
+}
+async function ensureClaudeSymlink(claudeSkillsDir, slug) {
+  await mkdir2(claudeSkillsDir, { recursive: true });
+  const linkPath = join9(claudeSkillsDir, slug);
+  try {
+    await unlink(linkPath);
+  } catch {
   }
-  const agentsDir = join8(projectRoot, ".agents", "skills");
-  if (await pathExists(agentsDir)) {
-    return { projectRoot, skillsDir: agentsDir, convention: "agents" };
+  try {
+    await rm(linkPath, { recursive: true, force: true });
+  } catch {
   }
-  return { projectRoot, skillsDir: claudeDir, convention: "claude" };
+  await symlink(`../../.agents/skills/${slug}`, linkPath);
 }
 async function collectPackFiles(dir, manifest) {
   const results = [];
@@ -3488,7 +3999,7 @@ async function collectPackFiles(dir, manifest) {
   }
   const mainFile = manifest.main || "SKILL.md";
   if (!results.includes(mainFile)) {
-    const mainPath = join8(dir, mainFile);
+    const mainPath = join9(dir, mainFile);
     if (await pathExists(mainPath)) {
       results.unshift(mainFile);
     }
@@ -3505,7 +4016,7 @@ async function walkDir(dir) {
   }
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join9(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
       const sub = await walkDir(fullPath);
@@ -3523,7 +4034,7 @@ async function packSkill(dir, manifest) {
   }
   const entries = [];
   for (const relPath of fileList) {
-    const absPath = join8(dir, relPath);
+    const absPath = join9(dir, relPath);
     try {
       const data = await readFile4(absPath);
       entries.push({ path: relPath.replace(/\\/g, "/"), data });
@@ -3557,7 +4068,7 @@ function bumpVersion(current, bump) {
 }
 async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
   const meta = await client.get(skillApiPath(authorLogin, slug));
-  const targetDir = join8(skillsDir, slug);
+  const targetDir = join9(skillsDir, slug);
   await mkdir2(targetDir, { recursive: true });
   if (meta.has_files) {
     const res = await client.getRaw(`${skillApiPath(authorLogin, slug)}/download`);
@@ -3565,8 +4076,8 @@ async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
     const buf = Buffer.from(arrayBuf);
     const entries = extractZipBuffer(buf);
     for (const entry of entries) {
-      const filePath = join8(targetDir, entry.path);
-      const dir = join8(filePath, "..");
+      const filePath = join9(targetDir, entry.path);
+      const dir = join9(filePath, "..");
       await mkdir2(dir, { recursive: true });
       await writeFile3(filePath, entry.data);
     }
@@ -3579,7 +4090,7 @@ async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
   } else {
     const res = await client.getRaw(`${skillApiPath(authorLogin, slug)}/raw`);
     const content = await res.text();
-    await writeFile3(join8(targetDir, "SKILL.md"), content);
+    await writeFile3(join9(targetDir, "SKILL.md"), content);
     return {
       slug,
       name: meta.name,
@@ -3608,7 +4119,7 @@ function registerSkillsCommand(program2) {
     try {
       const dir = resolveSkillDir(pathArg);
       await mkdir2(dir, { recursive: true });
-      const skillMdPath = join8(dir, "SKILL.md");
+      const skillMdPath = join9(dir, "SKILL.md");
       if (await pathExists(skillMdPath)) {
         const raw = await readFile4(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
@@ -3637,7 +4148,7 @@ function registerSkillsCommand(program2) {
       const dir = resolveSkillDir(pathArg);
       const manifest = await loadSkillManifest(dir);
       const result = await packSkill(dir, manifest);
-      const outPath = join8(dir, result.filename);
+      const outPath = join9(dir, result.filename);
       await writeFile3(outPath, result.buffer);
       slog.info(`Packed ${result.files.length} files \u2192 ${result.filename} (${result.size} bytes)`);
       outputJson({
@@ -3683,7 +4194,7 @@ function registerSkillsCommand(program2) {
         if (opts.name) manifest.name = opts.name;
         if (opts.version) manifest.version = opts.version;
         if (opts.private !== void 0) manifest.private = opts.private;
-        content = await readFile4(join8(dir, manifest.main || "SKILL.md"), "utf-8");
+        content = await readFile4(join9(dir, manifest.main || "SKILL.md"), "utf-8");
         packResult = await packSkill(dir, manifest);
         slog.info(`Packed ${packResult.files.length} files (${packResult.size} bytes)`);
       }
@@ -3820,7 +4331,7 @@ function registerSkillsCommand(program2) {
   skills.command("version <bump> [path]").description("Bump skill version (patch | minor | major | x.y.z)").action(async (bump, pathArg) => {
     try {
       const dir = resolveSkillDir(pathArg);
-      const skillMdPath = join8(dir, "SKILL.md");
+      const skillMdPath = join9(dir, "SKILL.md");
       if (!await pathExists(skillMdPath)) {
         outputError("not_found", "No SKILL.md found. Run `agent-mesh skills init` first.");
       }
@@ -3839,8 +4350,8 @@ function registerSkillsCommand(program2) {
   skills.command("install <ref> [path]").description("Install a skill from agents.hot (use author/slug format)").option("--force", "Overwrite if already installed").action(async (ref, pathArg, opts) => {
     try {
       const { authorLogin, slug } = parseSkillRef(ref);
-      const { skillsDir } = await resolveSkillsRootAsync(pathArg);
-      const targetDir = join8(skillsDir, slug);
+      const { skillsDir, claudeSkillsDir } = await resolveSkillsRootAsync(pathArg);
+      const targetDir = join9(skillsDir, slug);
       if (await pathExists(targetDir)) {
         if (!opts.force) {
           outputError("already_installed", `Skill "${slug}" is already installed at ${targetDir}. Use --force to overwrite.`);
@@ -3850,6 +4361,7 @@ function registerSkillsCommand(program2) {
       slog.info(`Installing ${authorLogin}/${slug}...`);
       const client = createClient();
       const result = await downloadAndInstallSkill(client, authorLogin, slug, skillsDir);
+      await ensureClaudeSymlink(claudeSkillsDir, slug);
       slog.success(`Installed ${result.name} (${result.files_count} files)`);
       outputJson({
         success: true,
@@ -3878,11 +4390,11 @@ function registerSkillsCommand(program2) {
       const failed = [];
       if (ref) {
         const { authorLogin, slug } = parseSkillRef(ref);
-        const targetDir = join8(skillsDir, slug);
+        const targetDir = join9(skillsDir, slug);
         if (!await pathExists(targetDir)) {
           outputError("not_installed", `Skill "${slug}" is not installed. Use "skills install ${ref}" first.`);
         }
-        const skillMdPath = join8(targetDir, "SKILL.md");
+        const skillMdPath = join9(targetDir, "SKILL.md");
         let localVersion = "0.0.0";
         if (await pathExists(skillMdPath)) {
           const raw = await readFile4(skillMdPath, "utf-8");
@@ -3909,7 +4421,7 @@ function registerSkillsCommand(program2) {
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           const slug = entry.name;
-          const skillMdPath = join8(skillsDir, slug, "SKILL.md");
+          const skillMdPath = join9(skillsDir, slug, "SKILL.md");
           if (!await pathExists(skillMdPath)) {
             skipped.push({ slug, reason: "no_skill_md" });
             continue;
@@ -3929,7 +4441,7 @@ function registerSkillsCommand(program2) {
               skipped.push({ slug, reason: "up_to_date" });
             } else {
               slog.info(`Updating ${slug}: v${localVersion} \u2192 v${remoteVersion}...`);
-              await rm(join8(skillsDir, slug), { recursive: true, force: true });
+              await rm(join9(skillsDir, slug), { recursive: true, force: true });
               await downloadAndInstallSkill(client, authorLogin, slug, skillsDir);
               updated.push({ slug, name: remote.name, old_version: localVersion, new_version: remoteVersion });
             }
@@ -3949,12 +4461,16 @@ function registerSkillsCommand(program2) {
   });
   skills.command("remove <slug> [path]").description("Remove a locally installed skill").action(async (slug, pathArg) => {
     try {
-      const { skillsDir } = await resolveSkillsRootAsync(pathArg);
-      const targetDir = join8(skillsDir, slug);
+      const { skillsDir, claudeSkillsDir } = await resolveSkillsRootAsync(pathArg);
+      const targetDir = join9(skillsDir, slug);
       if (!await pathExists(targetDir)) {
         outputError("not_installed", `Skill "${slug}" is not installed at ${targetDir}`);
       }
       await rm(targetDir, { recursive: true, force: true });
+      try {
+        await unlink(join9(claudeSkillsDir, slug));
+      } catch {
+      }
       slog.success(`Removed skill: ${slug}`);
       outputJson({ success: true, removed: slug, path: targetDir });
     } catch (err) {
@@ -3977,7 +4493,7 @@ function registerSkillsCommand(program2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const slug = entry.name;
-        const skillMdPath = join8(skillsDir, slug, "SKILL.md");
+        const skillMdPath = join9(skillsDir, slug, "SKILL.md");
         if (!await pathExists(skillMdPath)) continue;
         const raw = await readFile4(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
@@ -4089,7 +4605,7 @@ function registerDiscoverCommand(program2) {
 }
 
 // src/commands/call.ts
-import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 var DEFAULT_BASE_URL4 = "https://agents.hot";
 async function submitRating(baseUrl, token, agentId, callId, rating) {
   const res = await fetch(`${baseUrl}/api/agents/${agentId}/rate`, {
@@ -4110,7 +4626,7 @@ async function submitRating(baseUrl, token, agentId, callId, rating) {
     throw new Error(msg);
   }
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function handleError2(err) {
@@ -4165,7 +4681,7 @@ async function asyncCall(opts) {
       log.error("Aborted");
       process.exit(1);
     }
-    await sleep5(pollInterval);
+    await sleep6(pollInterval);
     const pollRes = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${opts.id}/task-status/${request_id}`, {
       headers: { Authorization: `Bearer ${opts.token}` },
       signal: opts.signal
@@ -4199,7 +4715,7 @@ async function asyncCall(opts) {
         }
       }
       if (opts.outputFile && result) {
-        writeFileSync2(opts.outputFile, result);
+        writeFileSync3(opts.outputFile, result);
         if (!opts.json) log.info(`Saved to ${opts.outputFile}`);
       }
       if (!opts.json) {
@@ -4352,7 +4868,7 @@ Error: ${event.message}
     }
   }
   if (opts.outputFile && outputBuffer) {
-    writeFileSync2(opts.outputFile, outputBuffer);
+    writeFileSync3(opts.outputFile, outputBuffer);
     if (!opts.json) log.info(`Saved to ${opts.outputFile}`);
   }
   if (!opts.json) {
@@ -4376,7 +4892,7 @@ function registerCallCommand(program2) {
       const { id, name } = await resolveAgentId(agentInput, client);
       let taskDescription = opts.task;
       if (opts.inputFile) {
-        const content = readFileSync(opts.inputFile, "utf-8");
+        const content = readFileSync2(opts.inputFile, "utf-8");
         taskDescription = `${taskDescription}
 
 ---
@@ -4736,6 +5252,80 @@ function registerRateCommand(program2) {
   });
 }
 
+// src/commands/runtime.ts
+function parsePositiveInt(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flag} must be a positive integer`);
+  }
+  return parsed;
+}
+async function renderRuntimeConfig(title) {
+  const cfg = getRuntimeConfig();
+  const queue = createLocalRuntimeQueue(cfg);
+  try {
+    const snap = await queue.snapshot();
+    console.log("");
+    console.log(`  ${BOLD}${title}${RESET}`);
+    console.log("");
+    console.log(`  ${GRAY}Max active requests${RESET}   ${cfg.max_active_requests}`);
+    console.log(`  ${GRAY}Queue wait timeout${RESET}    ${Math.floor(cfg.queue_wait_timeout_ms / 1e3)}s`);
+    console.log(`  ${GRAY}Queue max length${RESET}      ${cfg.queue_max_length}`);
+    console.log("");
+    console.log(`  ${GRAY}Current active${RESET}        ${snap.active}`);
+    console.log(`  ${GRAY}Current queued${RESET}        ${snap.queued}`);
+    console.log("");
+  } catch (err) {
+    log.warn(`Failed to read local runtime queue status: ${String(err)}`);
+  }
+}
+function registerRuntimeCommand(program2) {
+  const runtime = program2.command("runtime").description("View or update local runtime queue limits (machine-local)");
+  runtime.command("show").description("Show current local runtime limits and queue status").action(async () => {
+    await renderRuntimeConfig("Local Runtime Settings");
+  });
+  runtime.command("set").description("Update local runtime limits").option("--max-active-requests <n>", "Max active requests running at once on this machine").option("--queue-wait-timeout <seconds>", "Max queue wait before failing (seconds)").option("--queue-max-length <n>", "Max queued requests before rejecting").action(async (opts) => {
+    try {
+      const updates = {};
+      if (opts.maxActiveRequests !== void 0) {
+        const n = parsePositiveInt(opts.maxActiveRequests, "--max-active-requests");
+        if (n > 1e4) throw new Error("--max-active-requests must be <= 10000");
+        updates.max_active_requests = n;
+      }
+      if (opts.queueWaitTimeout !== void 0) {
+        const sec = parsePositiveInt(opts.queueWaitTimeout, "--queue-wait-timeout");
+        if (sec > 86400) throw new Error("--queue-wait-timeout must be <= 86400 seconds");
+        updates.queue_wait_timeout_ms = sec * 1e3;
+      }
+      if (opts.queueMaxLength !== void 0) {
+        const n = parsePositiveInt(opts.queueMaxLength, "--queue-max-length");
+        if (n > 1e5) throw new Error("--queue-max-length must be <= 100000");
+        updates.queue_max_length = n;
+      }
+      if (Object.keys(updates).length === 0) {
+        throw new Error("No settings provided. Use --max-active-requests / --queue-wait-timeout / --queue-max-length");
+      }
+      const next = updateRuntimeConfig(updates);
+      log.success("Local runtime settings updated");
+      console.log(`  ${GRAY}max_active_requests${RESET} = ${next.max_active_requests}`);
+      console.log(`  ${GRAY}queue_wait_timeout_ms${RESET} = ${next.queue_wait_timeout_ms}`);
+      console.log(`  ${GRAY}queue_max_length${RESET} = ${next.queue_max_length}`);
+      console.log(`  ${GRAY}Note${RESET}: restart running agent processes to apply new limits.`);
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+  runtime.command("reset").description("Reset local runtime limits to defaults").action(async () => {
+    resetRuntimeConfig();
+    log.success("Local runtime settings reset to defaults");
+    console.log(`  ${GRAY}max_active_requests${RESET} = ${DEFAULT_RUNTIME_CONFIG.max_active_requests}`);
+    console.log(`  ${GRAY}queue_wait_timeout_ms${RESET} = ${DEFAULT_RUNTIME_CONFIG.queue_wait_timeout_ms}`);
+    console.log(`  ${GRAY}queue_max_length${RESET} = ${DEFAULT_RUNTIME_CONFIG.queue_max_length}`);
+    console.log(`  ${GRAY}Note${RESET}: restart running agent processes to apply new limits.`);
+  });
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -4765,4 +5355,5 @@ registerStatsCommand(program);
 registerSubscribeCommand(program);
 registerRegisterCommand(program);
 registerRateCommand(program);
+registerRuntimeCommand(program);
 program.parse();

package/dist/{list-6CHWMM3O.js → list-KMJ463VL.js}

@@ -2,7 +2,7 @@
 import {
   ListTUI,
   registerListCommand
-} from "./chunk-GIEYJIVW.js";
+} from "./chunk-U32JDKSN.js";
 export {
   ListTUI,
   registerListCommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-mesh",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "description": "CLI bridge connecting local AI agents to the Agents.Hot platform",
   "type": "module",
   "bin": {