agentbnb 4.0.4 → 5.1.1

package/dist/index.js

@@ -212,6 +212,85 @@ function insertRequestLog(db, entry) {
   );
 }
 
+// src/feedback/store.ts
+import { randomUUID } from "crypto";
+function initFeedbackTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY,
+      transaction_id TEXT NOT NULL,
+      provider_agent TEXT NOT NULL,
+      skill_id TEXT NOT NULL,
+      requester_agent TEXT NOT NULL,
+      rating INTEGER NOT NULL,
+      latency_ms INTEGER NOT NULL,
+      result_quality TEXT NOT NULL,
+      quality_details TEXT,
+      would_reuse INTEGER NOT NULL,
+      cost_value_ratio TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS feedback_provider_idx ON feedback(provider_agent);
+    CREATE INDEX IF NOT EXISTS feedback_skill_idx ON feedback(skill_id);
+  `);
+}
+function getFeedbackForProvider(db, providerAgent, sinceDays) {
+  let rows;
+  if (sinceDays !== void 0) {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+        AND timestamp >= datetime('now', ? || ' days')
+      ORDER BY timestamp DESC
+    `).all(providerAgent, `-${sinceDays}`);
+  } else {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+      ORDER BY timestamp DESC
+    `).all(providerAgent);
+  }
+  return rows.map(rowToFeedback);
+}
+function rowToFeedback(row) {
+  return {
+    transaction_id: row["transaction_id"],
+    provider_agent: row["provider_agent"],
+    skill_id: row["skill_id"],
+    requester_agent: row["requester_agent"],
+    rating: row["rating"],
+    latency_ms: row["latency_ms"],
+    result_quality: row["result_quality"],
+    quality_details: row["quality_details"] ?? void 0,
+    would_reuse: row["would_reuse"] === 1,
+    cost_value_ratio: row["cost_value_ratio"],
+    timestamp: row["timestamp"]
+  };
+}
+
+// src/evolution/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function initEvolutionTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_versions (
+      id TEXT PRIMARY KEY,
+      template_name TEXT NOT NULL,
+      template_version TEXT NOT NULL,
+      publisher_agent TEXT NOT NULL,
+      changelog TEXT NOT NULL,
+      core_memory_snapshot TEXT NOT NULL,
+      fitness_improvement REAL NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS evolution_template_idx
+      ON evolution_versions(template_name, created_at DESC);
+  `);
+}
+
 // src/registry/store.ts
 var V2_FTS_TRIGGERS = `
   DROP TRIGGER IF EXISTS cards_ai;
@@ -366,6 +445,8 @@ function openDatabase(path = ":memory:") {
     );
   `);
   createRequestLogTable(db);
+  initFeedbackTable(db);
+  initEvolutionTable(db);
   runMigrations(db);
   return db;
 }
@@ -509,6 +590,52 @@ function listCards(db, owner) {
   return rows.map((row) => JSON.parse(row.data));
 }
 
+// src/feedback/reputation.ts
+var QUALITY_SCORES = {
+  excellent: 1,
+  good: 0.8,
+  acceptable: 0.6,
+  poor: 0.3,
+  failed: 0
+};
+var COST_VALUE_SCORES = {
+  great: 1,
+  fair: 0.6,
+  overpriced: 0.2
+};
+var DECAY_DAYS = 30;
+var WEIGHTS = {
+  rating: 0.4,
+  quality: 0.3,
+  would_reuse: 0.2,
+  cost_value: 0.1
+};
+function computeReputation(feedbacks) {
+  if (feedbacks.length === 0) return 0.5;
+  const now = Date.now();
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const fb of feedbacks) {
+    const feedbackDate = new Date(fb.timestamp).getTime();
+    const ageDays = Math.max(0, (now - feedbackDate) / (1e3 * 60 * 60 * 24));
+    const recencyWeight = Math.exp(-ageDays / DECAY_DAYS);
+    const ratingScore = (fb.rating - 1) / 4;
+    const qualityScore = QUALITY_SCORES[fb.result_quality];
+    const reuseScore = fb.would_reuse ? 1 : 0;
+    const costScore = COST_VALUE_SCORES[fb.cost_value_ratio];
+    const componentScore = WEIGHTS.rating * ratingScore + WEIGHTS.quality * qualityScore + WEIGHTS.would_reuse * reuseScore + WEIGHTS.cost_value * costScore;
+    weightedSum += recencyWeight * componentScore;
+    totalWeight += recencyWeight;
+  }
+  if (totalWeight === 0) return 0.5;
+  const raw = weightedSum / totalWeight;
+  return Math.max(0, Math.min(1, raw));
+}
+function getReputationScore(db, agentId) {
+  const feedbacks = getFeedbackForProvider(db, agentId);
+  return computeReputation(feedbacks);
+}
+
 // src/registry/matcher.ts
 function searchCards(db, query, filters = {}) {
   const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
@@ -537,19 +664,34 @@ function searchCards(db, query, filters = {}) {
   const stmt = db.prepare(sql);
   const rows = stmt.all(...params);
   const results = rows.map((row) => JSON.parse(row.data));
+  let filtered = results;
   if (filters.apis_used && filters.apis_used.length > 0) {
     const requiredApis = filters.apis_used;
-    return results.filter((card) => {
+    filtered = filtered.filter((card) => {
       const cardApis = card.metadata?.apis_used ?? [];
       return requiredApis.every((api) => cardApis.includes(api));
     });
   }
-  return results;
+  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
+    filtered = applyReputationFilter(db, filtered, filters.min_reputation);
+  }
+  return filtered;
+}
+function applyReputationFilter(db, cards, minReputation) {
+  const owners = [...new Set(cards.map((c) => c.owner))];
+  const reputationMap = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    reputationMap.set(owner, getReputationScore(db, owner));
+  }
+  return cards.filter((card) => {
+    const score = reputationMap.get(card.owner) ?? 0.5;
+    return score >= minReputation;
+  });
 }
 
 // src/credit/ledger.ts
 import Database2 from "better-sqlite3";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var CREDIT_SCHEMA = `
   CREATE TABLE IF NOT EXISTS credit_balances (
     owner TEXT PRIMARY KEY,
@@ -605,7 +747,7 @@ function recordEarning(db, owner, amount, _cardId, receiptNonce) {
     ).run(amount, now, owner);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID(), owner, amount, "remote_earning", receiptNonce, now);
+    ).run(randomUUID3(), owner, amount, "remote_earning", receiptNonce, now);
   })();
 }
 
@@ -613,12 +755,12 @@ function recordEarning(db, owner, amount, _cardId, receiptNonce) {
 import Fastify from "fastify";
 
 // src/gateway/execute.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/credit/escrow.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function holdEscrow(db, owner, amount, cardId) {
-  const escrowId = randomUUID2();
+  const escrowId = randomUUID4();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const hold = db.transaction(() => {
     const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
@@ -633,7 +775,7 @@ function holdEscrow(db, owner, amount, cardId) {
     ).run(escrowId, owner, amount, cardId, "held", now);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID2(), owner, -amount, "escrow_hold", escrowId, now);
+    ).run(randomUUID4(), owner, -amount, "escrow_hold", escrowId, now);
   });
   hold();
   return escrowId;
@@ -662,7 +804,7 @@ function settleEscrow(db, escrowId, recipientOwner) {
     ).run("settled", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID2(), recipientOwner, escrow.amount, "settlement", escrowId, now);
+    ).run(randomUUID4(), recipientOwner, escrow.amount, "settlement", escrowId, now);
   });
   settle();
 }
@@ -687,7 +829,7 @@ function releaseEscrow(db, escrowId) {
     ).run("released", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID2(), escrow.owner, escrow.amount, "refund", escrowId, now);
+    ).run(randomUUID4(), escrow.owner, escrow.amount, "refund", escrowId, now);
   });
   release();
 }
@@ -709,7 +851,7 @@ function confirmEscrowDebit(db, escrowId) {
     ).run("settled", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID2(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
+    ).run(randomUUID4(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
   });
   confirm();
 }
@@ -858,7 +1000,7 @@ async function executeCapabilityRequest(opts) {
     updateReputation(registryDb, cardId, false, latencyMs);
     try {
       insertRequestLog(registryDb, {
-        id: randomUUID3(),
+        id: randomUUID5(),
         card_id: cardId,
         card_name: cardName,
         skill_id: resolvedSkillId,
@@ -884,7 +1026,7 @@ async function executeCapabilityRequest(opts) {
     updateReputation(registryDb, cardId, true, latencyMs);
     try {
       insertRequestLog(registryDb, {
-        id: randomUUID3(),
+        id: randomUUID5(),
         card_id: cardId,
         card_name: cardName,
         skill_id: resolvedSkillId,
@@ -1787,10 +1929,13 @@ var CommandExecutor = class {
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
+    const env = { ...process.env };
+    delete env["CLAUDECODE"];
     try {
-      const result = await execFileAsync2("/bin/sh", ["-c", interpolatedCommand], {
+      const result = await execFileAsync2("/bin/sh", ["-c", `${interpolatedCommand} < /dev/null`], {
         timeout,
         cwd,
+        env,
         maxBuffer: 10 * 1024 * 1024
         // 10 MB
       });
@@ -1842,7 +1987,7 @@ var CommandExecutor = class {
 };
 
 // src/conductor/task-decomposer.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var TEMPLATES = {
   "video-production": {
     keywords: ["video", "demo", "clip", "animation"],
@@ -1937,7 +2082,7 @@ function decompose(task, _availableCapabilities) {
   for (const template of Object.values(TEMPLATES)) {
     const matched = template.keywords.some((kw) => lower.includes(kw));
     if (!matched) continue;
-    const ids = template.steps.map(() => randomUUID4());
+    const ids = template.steps.map(() => randomUUID6());
     return template.steps.map((step, i) => ({
       id: ids[i],
       description: step.description,
@@ -1951,10 +2096,10 @@ function decompose(task, _availableCapabilities) {
 }
 
 // src/gateway/client.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 async function requestCapability(opts) {
   const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
-  const id = randomUUID5();
+  const id = randomUUID7();
   const payload = {
     jsonrpc: "2.0",
     id,
@@ -2024,10 +2169,10 @@ async function requestViaRelay(relay, opts) {
 }
 
 // src/autonomy/tiers.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/cli/peers.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
@@ -2135,11 +2280,20 @@ function minMaxNormalize(values) {
 function scorePeers(candidates, selfOwner) {
   const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
   if (eligible.length === 0) return [];
-  const successRates = eligible.map((c) => c.card.metadata?.success_rate ?? 0.5);
+  const successRates = eligible.map((c) => {
+    if (c.skillMetadata?.success_rate !== void 0) {
+      return c.skillMetadata.success_rate;
+    }
+    return c.card.metadata?.success_rate ?? 0.5;
+  });
   const costEfficiencies = eligible.map((c) => c.cost === 0 ? 1 : 1 / c.cost);
   const idleRates = eligible.map((c) => {
+    if (c.skillInternal !== void 0) {
+      const skillIdleRate = c.skillInternal["idle_rate"];
+      if (typeof skillIdleRate === "number") return skillIdleRate;
+    }
     const internal = c.card._internal;
-    const idleRate = internal?.idle_rate;
+    const idleRate = internal?.["idle_rate"];
     return typeof idleRate === "number" ? idleRate : 1;
   });
   const normSuccess = minMaxNormalize(successRates);
@@ -2662,7 +2816,7 @@ var ConductorMode = class {
 
 // src/credit/escrow-receipt.ts
 import { z as z3 } from "zod";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var EscrowReceiptSchema = z3.object({
   requester_owner: z3.string().min(1),
   requester_public_key: z3.string().min(1),
@@ -2682,7 +2836,7 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
     card_id: opts.cardId,
     ...opts.skillId ? { skill_id: opts.skillId } : {},
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nonce: randomUUID8()
+    nonce: randomUUID10()
   };
   const signature = signEscrowReceipt(receiptData, privateKey);
   const receipt = {
@@ -3053,7 +3207,7 @@ var AgentBnBProvider = class {
 
 // src/identity/guarantor.ts
 import { z as z5 } from "zod";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 var MAX_AGENTS_PER_GUARANTOR = 10;
 var GUARANTOR_CREDIT_POOL = 50;
 var GuarantorRecordSchema = z5.object({
@@ -3092,7 +3246,7 @@ function registerGuarantor(db, githubLogin) {
     );
   }
   const record = {
-    id: randomUUID9(),
+    id: randomUUID11(),
     github_login: githubLogin,
     agent_count: 0,
     credit_pool: GUARANTOR_CREDIT_POOL,
@@ -3166,7 +3320,7 @@ function getAgentGuarantor(db, agentId) {
 function initiateGithubAuth() {
   return {
     auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
-    state: randomUUID9()
+    state: randomUUID11()
   };
 }
 
@@ -3250,7 +3404,7 @@ var RelayMessageSchema = z6.discriminatedUnion("type", [
 ]);
 
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 
 // src/relay/relay-credit.ts
 function lookupCardPrice(registryDb, cardId, skillId) {
@@ -3308,10 +3462,10 @@ function releaseForRelay(creditDb, escrowId) {
 }
 
 // src/hub-agent/relay-bridge.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 
 // src/hub-agent/job-queue.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function updateJobStatus(db, jobId, status, result) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (result !== void 0) {
@@ -3432,7 +3586,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID12(),
+        id: randomUUID14(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -3774,7 +3928,7 @@ function registerWebSocketRelay(server, db, creditDb) {
 
 // src/relay/websocket-client.ts
 import WebSocket from "ws";
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 var RelayClient = class {
   ws = null;
   opts;
@@ -3871,7 +4025,7 @@ var RelayClient = class {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registered) {
       throw new Error("Not connected to registry relay");
     }
-    const id = randomUUID13();
+    const id = randomUUID15();
     const timeoutMs = opts.timeoutMs ?? 3e5;
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -4075,12 +4229,12 @@ var RelayClient = class {
 };
 
 // src/onboarding/index.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join5 } from "path";
 
 // src/cli/onboarding.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 import { createConnection } from "net";
 var KNOWN_API_KEYS = [
   "OPENAI_API_KEY",
@@ -4222,7 +4376,7 @@ function capabilitiesToV2Card(capabilities, owner, agentName) {
   }));
   const card = {
     spec_version: "2.0",
-    id: randomUUID15(),
+    id: randomUUID17(),
     owner,
     agent_name: agentName ?? owner,
     skills,

package/dist/{peers-E4MKNNDN.js → peers-CJ7T4RJO.js}

@@ -3,7 +3,8 @@ import {
   loadPeers,
   removePeer,
   savePeer
-} from "./chunk-EVBX22YU.js";
+} from "./chunk-HLUEOLSZ.js";
+import "./chunk-IVOYM3WG.js";
 export {
   findPeer,
   loadPeers,

package/dist/process-guard-CC7CNRQJ.js

@@ -0,0 +1,176 @@
+import {
+  AgentBnBError
+} from "./chunk-WGZ5AGOX.js";
+
+// src/runtime/process-guard.ts
+import { dirname, join } from "path";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+var ProcessGuard = class {
+  pidFilePath;
+  /**
+   * Creates a ProcessGuard that controls single-process ownership via pid file.
+   *
+   * @param pidFilePath - Absolute path to pid file. Defaults to ~/.agentbnb/.pid.
+   */
+  constructor(pidFilePath) {
+    this.pidFilePath = pidFilePath ?? join(homedir(), ".agentbnb", ".pid");
+  }
+  /**
+   * Acquires process lock atomically.
+   *
+   * Uses fs open mode 'wx' so lock creation is a single atomic operation.
+   * If a pid file already exists, stale pids are cleaned automatically and
+   * acquisition is retried.
+   *
+   * @param meta - Lock metadata excluding pid (pid is always current process pid).
+   * @throws {AgentBnBError} PROCESS_ALREADY_RUNNING if another live process holds lock.
+   */
+  acquire(meta) {
+    mkdirSync(dirname(this.pidFilePath), { recursive: true });
+    const payload = {
+      pid: process.pid,
+      started_at: meta.started_at,
+      port: meta.port,
+      owner: meta.owner
+    };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      let fd = null;
+      try {
+        fd = openSync(this.pidFilePath, "wx");
+        writeFileSync(fd, `${JSON.stringify(payload)}
+`, "utf8");
+        return;
+      } catch (err) {
+        const fsErr = err;
+        if (fsErr.code !== "EEXIST") {
+          throw err;
+        }
+        const cleaned = this.cleanupStaleLock();
+        if (cleaned) {
+          continue;
+        }
+        const running = this.readPidFile();
+        const details = running ? `pid=${running.pid} owner=${running.owner} port=${running.port}` : `pid-file=${this.pidFilePath}`;
+        throw new AgentBnBError(
+          `AgentBnB process already running (${details})`,
+          "PROCESS_ALREADY_RUNNING"
+        );
+      } finally {
+        if (fd !== null) {
+          closeSync(fd);
+        }
+      }
+    }
+    throw new AgentBnBError(
+      `Failed to acquire process lock: ${this.pidFilePath}`,
+      "PROCESS_GUARD_ACQUIRE_FAILED"
+    );
+  }
+  /**
+   * Releases process lock.
+   *
+   * Removes pid file only when:
+   * - lock belongs to current process, or
+   * - lock holder pid is stale.
+   */
+  release() {
+    const current = this.readPidFile();
+    if (!current) return;
+    if (current.pid === process.pid || !this.isPidAlive(current.pid)) {
+      this.safeUnlink();
+    }
+  }
+  /**
+   * Returns running process metadata if lock holder pid is alive.
+   * Automatically clears stale pid files.
+   *
+   * @returns Running metadata or null when no live lock holder exists.
+   */
+  getRunningMeta() {
+    const meta = this.readPidFile();
+    if (!meta) return null;
+    if (!this.isPidAlive(meta.pid)) {
+      this.safeUnlink();
+      return null;
+    }
+    return meta;
+  }
+  /**
+   * Returns true when a live lock holder exists.
+   */
+  isRunning() {
+    return this.getRunningMeta() !== null;
+  }
+  readPidFile() {
+    if (!existsSync(this.pidFilePath)) {
+      return null;
+    }
+    try {
+      const raw = readFileSync(this.pidFilePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!isPidFileContent(parsed)) {
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  cleanupStaleLock() {
+    const existing = this.readPidFile();
+    if (!existing) {
+      return this.safeUnlink();
+    }
+    if (this.isPidAlive(existing.pid)) {
+      return false;
+    }
+    return this.safeUnlink();
+  }
+  safeUnlink() {
+    try {
+      unlinkSync(this.pidFilePath);
+      return true;
+    } catch (err) {
+      const fsErr = err;
+      if (fsErr.code === "ENOENT") {
+        return false;
+      }
+      throw err;
+    }
+  }
+  isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      const killErr = err;
+      if (killErr.code === "EPERM") {
+        return true;
+      }
+      if (killErr.code === "ESRCH") {
+        return false;
+      }
+      return false;
+    }
+  }
+};
+function isPidFileContent(value) {
+  if (value === null || typeof value !== "object") return false;
+  const record = value;
+  return Number.isInteger(record["pid"]) && typeof record["started_at"] === "string" && Number.isInteger(record["port"]) && typeof record["owner"] === "string";
+}
+export {
+  ProcessGuard
+};

package/dist/{request-4GQSSM4B.js → request-YOWPXVLQ.js}

@@ -1,13 +1,20 @@
 import {
   createLedger
-} from "./chunk-HH24WMFN.js";
+} from "./chunk-FLY3WIQR.js";
+import {
+  RelayClient
+} from "./chunk-JOY533UH.js";
+import "./chunk-QT7TEVNV.js";
 import {
   AutoRequestor,
   BudgetManager,
-  DEFAULT_AUTONOMY_CONFIG,
   DEFAULT_BUDGET_CONFIG
-} from "./chunk-GGYC5U2Z.js";
-import "./chunk-FF226TIV.js";
+} from "./chunk-BTTL24TZ.js";
+import {
+  DEFAULT_AUTONOMY_CONFIG
+} from "./chunk-CSATDXZC.js";
+import "./chunk-ZX5623ER.js";
+import "./chunk-NH2FIERR.js";
 import {
   requestCapability
 } from "./chunk-XND2DWTZ.js";
@@ -15,18 +22,14 @@ import "./chunk-5AH3CMOX.js";
 import "./chunk-75OC6E4F.js";
 import {
   openDatabase
-} from "./chunk-T7NS2J2B.js";
+} from "./chunk-DFBX3BBD.js";
 import {
   openCreditDb
-} from "./chunk-DNWT5FZQ.js";
+} from "./chunk-EANI2N2V.js";
 import {
   loadKeyPair
 } from "./chunk-5KFI5X7B.js";
 import "./chunk-WGZ5AGOX.js";
-import {
-  RelayClient
-} from "./chunk-JOY533UH.js";
-import "./chunk-QT7TEVNV.js";
 
 // src/mcp/tools/request.ts
 import { z } from "zod";

package/dist/schema-7BSSLZ4S.js

@@ -0,0 +1,8 @@
+import {
+  FeedbackResponseSchema,
+  StructuredFeedbackSchema
+} from "./chunk-AUBHR7HH.js";
+export {
+  FeedbackResponseSchema,
+  StructuredFeedbackSchema
+};