abtars 0.1.0-alpha.1

package/bundle/chunk-VVEDVGCR.js

@@ -0,0 +1,981 @@
+import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  abmind
+} from "./chunk-OP7BTAWY.js";
+import {
+  auditDeny,
+  checkPath,
+  checkTool
+} from "./chunk-MPX525QO.js";
+import {
+  bumpRead,
+  setProvenance
+} from "./chunk-AR6GO6YC.js";
+import {
+  getDelegationTools
+} from "./chunk-UHRP745J.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-FMWKEPM7.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-JCJS4ZIB.js";
+import {
+  init_logger,
+  logInfo,
+  logWarn,
+  redactSecrets
+} from "./chunk-BUUVFUPO.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-X76UX47U.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-NWDBD4PA.js";
+
+// src/components/guardrails.ts
+var guardrails_exports = {};
+__export(guardrails_exports, {
+  checkCommand: () => checkCommand,
+  checkPath: () => checkPath2,
+  getSecurityMode: () => getSecurityMode,
+  isGuardrailsActive: () => isGuardrailsActive
+});
+import { resolve, sep } from "node:path";
+import { homedir } from "node:os";
+function getSecurityMode() {
+  const mode = getEnv().securityMode;
+  return mode || "off";
+}
+function isGuardrailsActive() {
+  return getSecurityMode() !== "off";
+}
+function checkPath2(path, mode) {
+  if (!isGuardrailsActive()) return null;
+  const resolved = resolve(path) + (path.endsWith("/") ? sep : "");
+  for (const blocked of BLOCKED_PATHS) {
+    if (resolved.startsWith(blocked) || resolved === blocked.slice(0, -1)) {
+      return `Path blocked by guardrails: ${path}`;
+    }
+  }
+  if (mode === "write") {
+    for (const wb of WRITE_BLOCKED) {
+      if (resolved.startsWith(wb) || resolved === wb) {
+        return `Write blocked by guardrails: ${path}`;
+      }
+    }
+  }
+  return null;
+}
+function checkCommand(cmd) {
+  if (!isGuardrailsActive()) return null;
+  const trimmed = cmd.trim().toLowerCase();
+  for (const prefix of BLOCKED_COMMAND_PREFIXES) {
+    if (trimmed.startsWith(prefix.toLowerCase())) {
+      logWarn(TAG3, `Blocked command: ${cmd.slice(0, 100)}`);
+      return `Command blocked by guardrails: matches '${prefix.trim()}'`;
+    }
+  }
+  return null;
+}
+var TAG3, HOME, BLOCKED_PATHS, WRITE_BLOCKED, BLOCKED_COMMAND_PREFIXES;
+var init_guardrails = __esm({
+  "src/components/guardrails.ts"() {
+    "use strict";
+    init_env_schema();
+    init_logger();
+    TAG3 = "guardrails";
+    HOME = homedir();
+    BLOCKED_PATHS = [
+      `${HOME}/.ssh${sep}`,
+      `${HOME}/.abtars/secret${sep}`,
+      `/etc${sep}`,
+      `/proc${sep}`,
+      `/sys${sep}`,
+      `/dev${sep}`,
+      `/root${sep}`,
+      `/run${sep}`
+    ];
+    WRITE_BLOCKED = [
+      `${HOME}/.abtars/config/peers.json`,
+      `${HOME}/.kiro${sep}`
+    ];
+    BLOCKED_COMMAND_PREFIXES = [
+      "sudo ",
+      "npm publish",
+      "git push ",
+      "chmod 777",
+      "rm -rf /"
+    ];
+  }
+});
+
+// src/components/transport/tool-registry.ts
+init_logger();
+init_log_and_swallow();
+import { execFile as execFile2 } from "node:child_process";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/components/transport/skill-authoring.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync, renameSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+init_paths();
+init_logger();
+init_log_and_swallow();
+var TAG = "skill-authoring";
+var NAME_RE = /^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/;
+var MIN_BYTES = 100;
+var MAX_BYTES = 5e4;
+var MAX_TAGS = 5;
+function skillsDir() {
+  return join(abtarsHome(), "skills");
+}
+function selfDir() {
+  return join(skillsDir(), "self");
+}
+function trashDir() {
+  return join(skillsDir(), ".trash");
+}
+function auditLogPath() {
+  return join(abtarsHome(), "logs", "skill-authoring.log");
+}
+function audit(entry) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${entry}
+`;
+  try {
+    const dir = join(abtarsHome(), "logs");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    appendFileSync(auditLogPath(), line);
+  } catch (err) {
+    logAndSwallow(TAG, "audit write", err);
+  }
+}
+function validate(name, description, content) {
+  if (!NAME_RE.test(name)) return `Invalid name "${name}". Must be 3-64 chars, lowercase alphanumeric + hyphens, no leading/trailing hyphens.`;
+  const desc = description.trim();
+  if (desc.length < 1 || desc.length > 120) return `Description must be 1-120 chars (got ${desc.length}).`;
+  const bytes = Buffer.byteLength(content, "utf-8");
+  if (bytes < MIN_BYTES) return `Content too short (${bytes} bytes, minimum ${MIN_BYTES}). Write a useful skill, not a one-liner.`;
+  if (bytes > MAX_BYTES) return `Content too large (${bytes} bytes, maximum ${MAX_BYTES}). Split into a skill + references/ files.`;
+  const path = join(selfDir(), name, "SKILL.md");
+  if (existsSync(path)) return `Skill "${name}" already exists. Use skill_update to modify it.`;
+  const scan = abmind()?.scanForInjection(content);
+  if (scan && !scan.safe) return `Content blocked by injection scanner: ${scan.flags[0]?.category ?? "unknown"} (score=${scan.score}). Rephrase the content.`;
+  return null;
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
+  if (!match) return { meta: {}, body: raw };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    if (typeof val === "string" && val.startsWith("[") && val.endsWith("]")) {
+      val = val.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    meta[key] = val;
+  }
+  return { meta, body: match[2] };
+}
+function serializeFrontmatter(meta) {
+  const lines = ["---"];
+  for (const [k, v] of Object.entries(meta)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v) && v.length > 0) {
+      lines.push(`${k}: [${v.join(", ")}]`);
+    } else if (!Array.isArray(v)) {
+      lines.push(`${k}: ${v}`);
+    }
+  }
+  lines.push("---\n\n");
+  return lines.join("\n");
+}
+function guardSelfSkill(name) {
+  if (!NAME_RE.test(name)) return `Invalid name "${name}".`;
+  const path = join(selfDir(), name, "SKILL.md");
+  if (!existsSync(path)) return `Skill "${name}" not found in self/.`;
+  return null;
+}
+var skillCreateTool = {
+  name: "skill_create",
+  description: "Persist a new procedural skill to disk. Use when you've solved a novel task, discovered a workflow, or received a correction worth remembering as a repeatable recipe. Skills become available in future sessions via the skills_catalog.",
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Skill identifier, kebab-case, e.g. 'fix-pnpm-workspace-drift'. 3-64 chars, [a-z0-9-]+." },
+      description: { type: "string", description: "One-line description, max 120 chars. Shown in skills_catalog." },
+      content: { type: "string", description: "Skill body in Markdown. Starts with # <Title>. No frontmatter \u2014 the tool writes it." },
+      tags: { type: "array", items: { type: "string" }, description: "Optional tags for categorization (max 5). E.g. ['tools', 'browser', 'debugging']." },
+      related: { type: "array", items: { type: "string" }, description: "Optional related skill names." }
+    },
+    required: ["name", "description", "content"]
+  },
+  async execute(args) {
+    const { name, description, content, tags, related } = args;
+    const error = validate(name, description, content);
+    if (error) {
+      audit(`skill_create name=${name} bytes=${content.length} ok=false error="${error}"`);
+      return JSON.stringify({ error });
+    }
+    const tagList = (tags ?? []).slice(0, MAX_TAGS).map((t) => t.toLowerCase().trim()).filter(Boolean);
+    const relList = (related ?? []).filter(Boolean);
+    const tagsLine = tagList.length > 0 ? `tags: [${tagList.join(", ")}]
+` : "";
+    const relatedLine = relList.length > 0 ? `related: [${relList.join(", ")}]
+` : "";
+    const frontmatter = `---
+name: ${name}
+description: ${description.trim()}
+${tagsLine}${relatedLine}---
+
+`;
+    const fullContent = frontmatter + content;
+    const dir = join(selfDir(), name);
+    const filePath = join(dir, "SKILL.md");
+    const tmpPath = filePath + ".tmp";
+    try {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(tmpPath, fullContent, "utf-8");
+      renameSync(tmpPath, filePath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      audit(`skill_create name=${name} bytes=${content.length} ok=false error="write failed: ${msg}"`);
+      return JSON.stringify({ error: `Write failed: ${msg}` });
+    }
+    setProvenance(name, "agent");
+    audit(`skill_create name=${name} tags=[${tagList.join(",")}] bytes=${content.length} ok=true`);
+    logInfo(TAG, `Created skill: self/${name} (${content.length} bytes)`);
+    return JSON.stringify({ ok: true, path: filePath, message: `Skill "${name}" created in self/. Available in skills_catalog after /skill reload.` });
+  }
+};
+var skillUpdateTool = {
+  name: "skill_update",
+  description: "Full rewrite of an existing skill's SKILL.md in self/. Preserves frontmatter fields (tags, related, description) when omitted by caller.",
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Skill name (must exist in self/)." },
+      description: { type: "string", description: "New description (optional \u2014 keeps existing if omitted)." },
+      content: { type: "string", description: "New skill body in Markdown (no frontmatter)." },
+      tags: { type: "array", items: { type: "string" }, description: "New tags (optional \u2014 keeps existing if omitted)." },
+      related: { type: "array", items: { type: "string" }, description: "New related skills (optional \u2014 keeps existing if omitted)." }
+    },
+    required: ["name", "content"]
+  },
+  async execute(args) {
+    const { name, content, description, tags, related } = args;
+    const guard = guardSelfSkill(name);
+    if (guard) {
+      audit(`skill_update name=${name} ok=false error="${guard}"`);
+      return JSON.stringify({ error: guard });
+    }
+    const bytes = Buffer.byteLength(content, "utf-8");
+    if (bytes < MIN_BYTES) return JSON.stringify({ error: `Content too short (${bytes} bytes, minimum ${MIN_BYTES}).` });
+    if (bytes > MAX_BYTES) return JSON.stringify({ error: `Content too large (${bytes} bytes, maximum ${MAX_BYTES}).` });
+    const scan = abmind()?.scanForInjection(content);
+    if (scan && !scan.safe) return JSON.stringify({ error: `Content blocked by injection scanner: ${scan.flags[0]?.category ?? "unknown"}.` });
+    const filePath = join(selfDir(), name, "SKILL.md");
+    const existing = readFileSync(filePath, "utf-8");
+    const { meta } = parseFrontmatter(existing);
+    const merged = { ...meta, name };
+    if (description !== void 0) merged["description"] = description.trim();
+    if (tags !== void 0) merged["tags"] = tags.slice(0, MAX_TAGS).map((t) => t.toLowerCase().trim()).filter(Boolean);
+    if (related !== void 0) merged["related"] = related.filter(Boolean);
+    const fullContent = serializeFrontmatter(merged) + content;
+    const tmpPath = filePath + ".tmp";
+    try {
+      writeFileSync(tmpPath, fullContent, "utf-8");
+      renameSync(tmpPath, filePath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      audit(`skill_update name=${name} ok=false error="write failed: ${msg}"`);
+      return JSON.stringify({ error: `Write failed: ${msg}` });
+    }
+    audit(`skill_update name=${name} bytes=${bytes} ok=true`);
+    logInfo(TAG, `Updated skill: self/${name} (${bytes} bytes)`);
+    return JSON.stringify({ ok: true, path: filePath, message: `Skill "${name}" updated.` });
+  }
+};
+var skillPatchTool = {
+  name: "skill_patch",
+  description: "Targeted find-and-replace within a skill's SKILL.md in self/. old_string must match exactly once.",
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Skill name (must exist in self/)." },
+      old_string: { type: "string", description: "Exact string to find (must match once)." },
+      new_string: { type: "string", description: "Replacement string." }
+    },
+    required: ["name", "old_string", "new_string"]
+  },
+  async execute(args) {
+    const { name, old_string, new_string } = args;
+    const guard = guardSelfSkill(name);
+    if (guard) {
+      audit(`skill_patch name=${name} ok=false error="${guard}"`);
+      return JSON.stringify({ error: guard });
+    }
+    const filePath = join(selfDir(), name, "SKILL.md");
+    const existing = readFileSync(filePath, "utf-8");
+    const count = existing.split(old_string).length - 1;
+    if (count === 0) return JSON.stringify({ error: `old_string not found in skill "${name}".` });
+    if (count > 1) return JSON.stringify({ error: `old_string matches ${count} times \u2014 must match exactly once.` });
+    const patched = existing.replace(old_string, new_string);
+    const scan = abmind()?.scanForInjection(patched);
+    if (scan && !scan.safe) return JSON.stringify({ error: `Patched content blocked by injection scanner: ${scan.flags[0]?.category ?? "unknown"}.` });
+    const tmpPath = filePath + ".tmp";
+    try {
+      writeFileSync(tmpPath, patched, "utf-8");
+      renameSync(tmpPath, filePath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      audit(`skill_patch name=${name} ok=false error="write failed: ${msg}"`);
+      return JSON.stringify({ error: `Write failed: ${msg}` });
+    }
+    audit(`skill_patch name=${name} ok=true`);
+    logInfo(TAG, `Patched skill: self/${name}`);
+    return JSON.stringify({ ok: true, path: filePath, message: `Skill "${name}" patched.` });
+  }
+};
+var skillRemoveTool = {
+  name: "skill_remove",
+  description: "Soft-delete a skill from self/ by moving it to .trash/ (recoverable for 7 days).",
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Skill name (must exist in self/)." }
+    },
+    required: ["name"]
+  },
+  async execute(args) {
+    const { name } = args;
+    const guard = guardSelfSkill(name);
+    if (guard) {
+      audit(`skill_remove name=${name} ok=false error="${guard}"`);
+      return JSON.stringify({ error: guard });
+    }
+    const srcDir = join(selfDir(), name);
+    const ts = Date.now();
+    const destDir = join(trashDir(), `${name}-${ts}`);
+    try {
+      mkdirSync(trashDir(), { recursive: true });
+      renameSync(srcDir, destDir);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      audit(`skill_remove name=${name} ok=false error="move failed: ${msg}"`);
+      return JSON.stringify({ error: `Move failed: ${msg}` });
+    }
+    audit(`skill_remove name=${name} dest=${destDir} ok=true`);
+    logInfo(TAG, `Removed skill: self/${name} \u2192 .trash/`);
+    return JSON.stringify({ ok: true, message: `Skill "${name}" moved to .trash/. Will be pruned after 7 days.` });
+  }
+};
+
+// src/components/transport/mcp-tool.ts
+init_logger();
+init_log_and_swallow();
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var TAG2 = "mcp";
+var daemonStarted = false;
+async function ensureDaemon() {
+  if (daemonStarted) return;
+  try {
+    await execFileAsync("mcporter", ["daemon", "start"], { timeout: 1e4 });
+    daemonStarted = true;
+    logInfo(TAG2, "mcporter daemon started (on-demand)");
+  } catch {
+    logWarn(TAG2, "mcporter daemon start failed \u2014 calls may still work if already running");
+    daemonStarted = true;
+  }
+}
+var mcpTool = {
+  name: "mcp",
+  description: "Call an MCP server tool via mcporter. Available servers shown by /mcp command. Use when you need JIRA, presentations, or other MCP-connected services.",
+  parameters: {
+    type: "object",
+    properties: {
+      server: { type: "string", description: "Server name (e.g. 'pptx', 'atlassian')" },
+      tool: { type: "string", description: "Tool name (e.g. 'jira_search', 'create_presentation')" },
+      args: { type: "string", description: `Tool arguments as JSON string (e.g. '{"query": "assignee = me"}')` }
+    },
+    required: ["server", "tool"]
+  },
+  async execute(params) {
+    await ensureDaemon();
+    const { server, tool, args } = params;
+    const cliArgs = ["call", `${server}.${tool}`];
+    if (args) {
+      try {
+        const parsed = JSON.parse(args);
+        for (const [k, v] of Object.entries(parsed)) cliArgs.push(`${k}=${v}`);
+      } catch (err) {
+        logAndSwallow(TAG2, "JSON.parse mcp args", err);
+        cliArgs.push(args);
+      }
+    }
+    try {
+      const { stdout } = await execFileAsync("mcporter", cliArgs, { timeout: 3e4, encoding: "utf-8" });
+      return stdout;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return JSON.stringify({ error: `mcp call failed: ${msg}` });
+    }
+  }
+};
+
+// src/components/transport/tool-registry.ts
+var TAG4 = "tool_registry";
+var AUDIT_DIR = join2(process.env["ABTARS_HOME"] ?? join2(homedir2(), ".abtars"), "logs");
+var AUDIT_PATH = join2(AUDIT_DIR, "audit.jsonl");
+try {
+  mkdirSync2(AUDIT_DIR, { recursive: true });
+} catch (err) {
+  logAndSwallow(TAG4, "mkdirSync audit dir", err);
+}
+function audit2(entry) {
+  try {
+    appendFileSync2(AUDIT_PATH, JSON.stringify(entry) + "\n");
+  } catch (err) {
+    logAndSwallow(TAG4, "audit write", err);
+  }
+}
+var BASH_TIMEOUT_MS = 3e5;
+var CLI_TIMEOUT_MS = 6e4;
+var BLOCKED_PATTERNS = [
+  /\bmain\.js\b/,
+  // node .../current/dist/main.js ...
+  /\babtars\.sh\b/,
+  // the launcher
+  /\bwatchdog\.sh\b/,
+  // the watchdog
+  /\blaunchctl\s+(load|bootstrap|kickstart|start)\b/
+  // launchd bridge start
+];
+function isBridgeSpawnCommand(cmd) {
+  return BLOCKED_PATTERNS.some((p) => p.test(cmd));
+}
+function isBridgeKillCommand(cmd) {
+  const pid = process.pid;
+  const ppid = process.ppid;
+  if (new RegExp(`\\bkill\\s+(-\\d+\\s+)?${pid}\\b`).test(cmd)) return true;
+  if (new RegExp(`\\bkill\\s+(-\\d+\\s+)?${ppid}\\b`).test(cmd)) return true;
+  if (/\b(pkill|killall)\b.*\b(abtars|main\.js|watchdog)\b/.test(cmd)) return true;
+  if (/\bkill\b.*\$\(.*pgrep.*abtars/.test(cmd)) return true;
+  return false;
+}
+function runBash(cmd, timeout = BASH_TIMEOUT_MS, signal) {
+  const { checkCommand: checkCommand2 } = (init_guardrails(), __toCommonJS(guardrails_exports));
+  const cmdBlock = checkCommand2(cmd);
+  if (cmdBlock) {
+    logWarn("tool-registry", `Guardrails blocked: ${cmd.slice(0, 200)}`);
+    return Promise.resolve(JSON.stringify({ stderr: cmdBlock, exit_code: 126 }));
+  }
+  if (isBridgeSpawnCommand(cmd)) {
+    logWarn("tool-registry", `Blocked bridge-spawn command: ${cmd.slice(0, 200)}`);
+    return Promise.resolve(JSON.stringify({
+      stderr: "Command blocked: this would spawn/restart a bridge or watchdog process. The bridge is already running under launchd+watchdog supervision; use launchctl inspection commands (launchctl list, launchctl print) or signal the existing process instead.",
+      exit_code: 126
+    }));
+  }
+  if (isBridgeKillCommand(cmd)) {
+    logWarn("tool-registry", `Blocked bridge-kill command: ${cmd.slice(0, 200)}`);
+    return Promise.resolve(JSON.stringify({
+      stderr: "Command blocked: this would kill the bridge process (yourself). Ask the user to send /restart for a session reset or restart the bridge manually.",
+      exit_code: 126
+    }));
+  }
+  return new Promise((resolve2) => {
+    const child = execFile2("bash", ["-c", cmd], { timeout, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      const result = {};
+      if (stdout) result["stdout"] = stdout.slice(0, 5e4);
+      if (stderr) result["stderr"] = stderr.slice(0, 1e4);
+      if (err) result["exit_code"] = err.code ?? 1;
+      else result["exit_code"] = 0;
+      resolve2(JSON.stringify(result));
+    });
+    if (signal) {
+      if (signal.aborted) {
+        child.kill("SIGTERM");
+        return;
+      }
+      const onAbort = () => {
+        child.kill("SIGTERM");
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      child.on("exit", () => signal.removeEventListener("abort", onAbort));
+    }
+  });
+}
+var memoryBackend = null;
+function setMemoryBackend(backend) {
+  memoryBackend = backend;
+}
+var _peerActivityCb = null;
+function setPeerActivityCallback(cb) {
+  _peerActivityCb = cb;
+}
+var bashTool = {
+  name: "execute_bash",
+  description: "Execute a bash command. Use for file operations, git, running scripts, and any shell command. Commands that would spawn or restart a bridge/watchdog process (node main.js, abtars.sh, watchdog.sh, launchctl load/bootstrap/kickstart/start) are blocked \u2014 the bridge is already supervised.",
+  parameters: {
+    type: "object",
+    properties: { command: { type: "string", description: "The bash command to execute" } },
+    required: ["command"]
+  },
+  execute: (args, context) => runBash(args["command"] ?? "", BASH_TIMEOUT_MS, context?.signal)
+};
+var _storeCount = 0;
+var STORE_CAP = 20;
+function resetStoreCounter() {
+  _storeCount = 0;
+}
+var memoryStoreTool = {
+  name: "memory_store",
+  description: "Store a memory. Use after learning something about the user, their preferences, decisions, or facts worth remembering.",
+  parameters: {
+    type: "object",
+    properties: {
+      translated: { type: "string", description: "Memory content in English" },
+      original: { type: "string", description: "Memory content in original language (if not English)" },
+      type: { type: "string", enum: ["fact", "preference", "decision", "experience", "skill", "relationship", "goal"], description: "Memory type" },
+      emotion: { type: "integer", description: "Emotion score -5 to +5 (0=neutral)" },
+      confidence: { type: "integer", description: "Confidence 1-5 (3=default)" },
+      classification: { type: "integer", description: "0=public (general knowledge), 1=internal (default), 2=confidential (personal preferences, habits, opinions about specific users), 3=secret (credentials, API keys, tokens, passwords \u2014 store IMMEDIATELY with exact string, never paraphrase, never wait for Dreamy)" }
+    },
+    required: ["translated", "type"]
+  },
+  async execute(args, context) {
+    if (++_storeCount > STORE_CAP) {
+      return JSON.stringify({ stored: false, error: "Store limit reached for this session. Move to next task." });
+    }
+    if (memoryBackend) {
+      try {
+        const params = {
+          userId: context?.userId ?? "master",
+          contentEn: args["translated"] ?? "",
+          contentOriginal: args["original"] ?? args["translated"] ?? "",
+          memoryType: args["type"] ?? "fact",
+          emotionScore: parseInt(args["emotion"] ?? "0", 10),
+          confidence: parseInt(args["confidence"] ?? "3", 10),
+          classification: parseInt(args["classification"] ?? "1", 10)
+        };
+        const result = await memoryBackend.instantStore({ ...params, createdBy: "tool:memory_store" });
+        return JSON.stringify(result);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("fts5") || msg.includes("corruption")) {
+          try {
+            memoryBackend.rebuildFtsIndexes();
+            logWarn("tool-registry", "FTS corruption detected \u2014 rebuilt indexes, retrying store");
+            const params = {
+              userId: context?.userId ?? "master",
+              contentEn: args["translated"] ?? "",
+              contentOriginal: args["original"] ?? args["translated"] ?? "",
+              memoryType: args["type"] ?? "fact",
+              emotionScore: parseInt(args["emotion"] ?? "0", 10),
+              confidence: parseInt(args["confidence"] ?? "3", 10),
+              classification: parseInt(args["classification"] ?? "1", 10)
+            };
+            const result = await memoryBackend.instantStore({ ...params, createdBy: "tool:memory_store" });
+            return JSON.stringify(result);
+          } catch (retryErr) {
+          }
+        }
+        return JSON.stringify({ error: msg });
+      }
+    }
+    let cmd = `abmind store --translated ${JSON.stringify(args["translated"] ?? "")} --type ${args["type"] ?? "fact"}`;
+    if (args["original"]) cmd += ` --original ${JSON.stringify(args["original"])}`;
+    if (args["emotion"]) cmd += ` --emotion-score ${args["emotion"]}`;
+    if (args["confidence"]) cmd += ` --confidence ${args["confidence"]}`;
+    if (args["classification"]) cmd += ` --classification ${args["classification"]}`;
+    return runBash(cmd, CLI_TIMEOUT_MS);
+  }
+};
+var memoryRecallTool = {
+  name: "memory_recall",
+  description: "Search memories by keyword or semantic query. Returns relevant stored memories.",
+  parameters: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query" },
+      limit: { type: "integer", description: "Max results (default 10)" }
+    },
+    required: ["query"]
+  },
+  async execute(args, context) {
+    if (memoryBackend) {
+      try {
+        const result = await memoryBackend.recall({
+          translated: [args["query"] ?? ""],
+          original: args["query"] ?? "",
+          userId: context?.userId ?? "master",
+          limit: parseInt(args["limit"] ?? "10", 10)
+        });
+        return JSON.stringify(result);
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    let cmd = `abmind recall ${JSON.stringify(args["query"] ?? "")}`;
+    if (args["limit"]) cmd += ` --limit ${args["limit"]}`;
+    return runBash(cmd, CLI_TIMEOUT_MS);
+  }
+};
+var memoryEditTool = {
+  name: "memory_edit",
+  description: "Edit an existing memory by ID. Change content, type, emotion, confidence, or classification.",
+  parameters: {
+    type: "object",
+    properties: {
+      memory_id: { type: "integer", description: "Memory ID to edit" },
+      translated: { type: "string", description: "New English content" },
+      original: { type: "string", description: "New original language content" },
+      type: { type: "string", description: "New memory type" },
+      emotion: { type: "integer", description: "New emotion score" },
+      confidence: { type: "integer", description: "New confidence" },
+      classification: { type: "integer", description: "New classification" },
+      caller: { type: "string", enum: ["kp", "dreamy"], description: "Who is making the edit" }
+    },
+    required: ["memory_id"]
+  },
+  async execute(args) {
+    if (memoryBackend) {
+      try {
+        const result = await memoryBackend.editMemory({
+          memoryId: parseInt(args["memory_id"] ?? "0", 10),
+          contentEn: args["translated"],
+          contentOriginal: args["original"],
+          memoryType: args["type"],
+          emotionScore: args["emotion"] ? parseInt(args["emotion"], 10) : void 0,
+          confidence: args["confidence"] ? parseInt(args["confidence"], 10) : void 0,
+          classification: args["classification"] ? parseInt(args["classification"], 10) : void 0,
+          caller: args["caller"] ?? "kp"
+        });
+        return JSON.stringify(result);
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    let cmd = `abmind edit --memory-id ${args["memory_id"] ?? "0"}`;
+    if (args["translated"]) cmd += ` --translated ${JSON.stringify(args["translated"])}`;
+    if (args["original"]) cmd += ` --original ${JSON.stringify(args["original"])}`;
+    if (args["type"]) cmd += ` --type ${args["type"]}`;
+    if (args["emotion"]) cmd += ` --emotion-score ${args["emotion"]}`;
+    if (args["confidence"]) cmd += ` --confidence ${args["confidence"]}`;
+    if (args["classification"]) cmd += ` --classification ${args["classification"]}`;
+    if (args["caller"]) cmd += ` --caller ${args["caller"]}`;
+    return runBash(cmd, CLI_TIMEOUT_MS);
+  }
+};
+var webBrowseTool = {
+  name: "web_browse",
+  description: "Browse a URL or perform a complex multi-step web task. For quick lookups use execute_bash with curl.",
+  parameters: {
+    type: "object",
+    properties: {
+      task: { type: "string", description: "What to do on the web" },
+      chat_id: { type: "string", description: "Chat ID for result delivery" },
+      engine: { type: "string", enum: ["patchright"], description: "Browser engine (default: patchright)" }
+    },
+    required: ["task", "chat_id"]
+  },
+  execute: (args) => {
+    let cmd = `abtars-browse --task ${JSON.stringify(args["task"] ?? "")} --chat-id ${args["chat_id"] ?? "0"}`;
+    if (args["engine"]) cmd += ` --engine ${args["engine"]}`;
+    return runBash(cmd, CLI_TIMEOUT_MS);
+  }
+};
+var todoTool = {
+  name: "todo_manage",
+  description: "Manage TODO items. Add, complete, or list tasks.",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["add", "done", "list", "remove"], description: "Action to perform" },
+      text: { type: "string", description: "TODO text (for add)" },
+      id: { type: "string", description: "TODO ID (for done/remove)" }
+    },
+    required: ["action"]
+  },
+  execute: (args) => {
+    const action = args["action"] ?? "list";
+    if (action === "add") return runBash(`abtars-todo add ${JSON.stringify(args["text"] ?? "")}`, CLI_TIMEOUT_MS);
+    if (action === "done") return runBash(`abtars-todo done ${args["id"] ?? ""}`, CLI_TIMEOUT_MS);
+    if (action === "remove") return runBash(`abtars-todo remove ${args["id"] ?? ""}`, CLI_TIMEOUT_MS);
+    return runBash("abtars-todo list", CLI_TIMEOUT_MS);
+  }
+};
+var _enqueueCron = null;
+function setEnqueueCron(fn) {
+  _enqueueCron = fn;
+}
+var _ircSend = null;
+function setIrcSend(fn) {
+  _ircSend = fn;
+}
+function setSecretGetDb(_db) {
+}
+var _sendDocument = null;
+function setSendDocument(fn) {
+  _sendDocument = fn;
+}
+var sendDocumentTool = {
+  name: "send_document",
+  description: "Send a file from disk to the user's Telegram chat. Use for delivering reports, daily summaries, logs, or any .md file the user asks for. Do not summarize \u2014 the raw file is sent as an attachment.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Absolute path to the file" },
+      caption: { type: "string", description: "Optional short caption (\u22641024 chars)" }
+    },
+    required: ["path"]
+  },
+  execute: async (args) => {
+    const path = args["path"];
+    if (!path) return JSON.stringify({ error: "path is required" });
+    if (!_sendDocument) return JSON.stringify({ error: "Telegram not configured (sendDocument unavailable)" });
+    try {
+      const messageId = await _sendDocument(path, args["caption"]);
+      return JSON.stringify({ ok: true, message_id: messageId });
+    } catch (err) {
+      return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+};
+var taskTool = {
+  name: "task_manage",
+  description: "Manage scheduled/recurring tasks (cron). Add, list, remove, pause, resume, or run tasks. Use action=run to execute a task immediately via the cron queue (isolated subagent).",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["add", "list", "remove", "pause", "resume", "run"], description: "Action" },
+      message: { type: "string", description: "Task message/command (for add)" },
+      schedule: { type: "string", description: "Cron schedule expression (for add)" },
+      type: { type: "string", enum: ["reminder", "script", "agent"], description: "Task type (for add)" },
+      chat_id: { type: "string", description: "Chat ID (for add)" },
+      id: { type: "string", description: "Task ID (for remove/pause/resume/run)" }
+    },
+    required: ["action"]
+  },
+  execute: (args) => {
+    const action = args["action"] ?? "list";
+    if (action === "list") return runBash("abtars-task list", CLI_TIMEOUT_MS);
+    if (action === "remove") return runBash(`abtars-task remove ${args["id"] ?? ""}`, CLI_TIMEOUT_MS);
+    if (action === "pause") return runBash(`abtars-task pause ${args["id"] ?? ""}`, CLI_TIMEOUT_MS);
+    if (action === "resume") return runBash(`abtars-task resume ${args["id"] ?? ""}`, CLI_TIMEOUT_MS);
+    if (action === "run") {
+      if (!_enqueueCron) return Promise.resolve(JSON.stringify({ error: "enqueueCron not available" }));
+      const err = _enqueueCron(args["id"] ?? "", true);
+      return Promise.resolve(JSON.stringify(err ? { error: err } : { ok: true, message: `Task ${args["id"]} enqueued for immediate execution` }));
+    }
+    let cmd = `abtars-task add --message ${JSON.stringify(args["message"] ?? "")}`;
+    if (args["schedule"]) cmd += ` --schedule ${JSON.stringify(args["schedule"])}`;
+    if (args["type"]) cmd += ` --type ${args["type"]}`;
+    if (args["chat_id"]) cmd += ` --chat-id ${args["chat_id"]}`;
+    return runBash(cmd, CLI_TIMEOUT_MS);
+  }
+};
+var peerSessionTool = {
+  name: "peer_session",
+  description: "Open or continue a peer-to-peer session with another agent. Messages persist across turns. Use only when the user explicitly asks to contact another agent.",
+  parameters: {
+    type: "object",
+    properties: {
+      peer_name: { type: "string", description: "Name of the peer (as in peers.json)" },
+      message: { type: "string", description: "Your message to the peer" },
+      session_id: { type: "string", description: "Session ID from previous call (omit for new conversation)" }
+    },
+    required: ["peer_name", "message"]
+  },
+  async execute(args) {
+    const { callPeer } = await import("./peer-client-52XYMNI7.js");
+    const { loadPeerConfig } = await import("./peer-config-VK6EDLN5.js");
+    const { getOrCreateSession, addTurn, isEnded, destroySession } = await import("./peer-sessions-EAXTNQ36.js");
+    const peerName = args.peer_name?.trim();
+    const message = args.message?.trim();
+    if (!peerName || !message) return JSON.stringify({ error: "peer_name and message required" });
+    const config = loadPeerConfig();
+    if (peerName === config.self.name) return JSON.stringify({ error: "Cannot chat with yourself" });
+    if (!config.peers[peerName]) return JSON.stringify({ error: `Unknown peer: ${peerName}` });
+    const session = getOrCreateSession(args.session_id?.trim() || void 0, peerName);
+    if (session.messages.length >= 20) {
+      destroySession(session.id);
+      return JSON.stringify({ session_id: session.id, response: "[SESSION_END] Turn limit reached.", ended: true, reason: "max-turns" });
+    }
+    addTurn(session, "user", message);
+    const prompt = session.messages.map((m) => `${m.role === "user" ? "You" : "Peer"}: ${m.content}`).join("\n") + "\n\nRespond to the latest message.";
+    try {
+      const response = await callPeer(peerName, prompt, config.maxHops);
+      addTurn(session, "assistant", response);
+      _peerActivityCb?.(`\u{1F916} Agents: ${config.self.name} \u2194 ${peerName} session. [turn ${session.messages.length}]`);
+      const { ended, reason } = isEnded(session, response);
+      if (ended) destroySession(session.id);
+      return JSON.stringify({ session_id: session.id, response, ended, reason });
+    } catch (err) {
+      destroySession(session.id);
+      return JSON.stringify({ error: `peer_session failed: ${err instanceof Error ? err.message : String(err)}`, session_id: session.id, ended: true });
+    }
+  }
+};
+var peerWakeupTool = {
+  name: "peer_wakeup",
+  description: "Send a wake-up signal to a peer that cannot reach us directly (firewall). The peer's bridge will call us back via A2A within seconds.",
+  parameters: {
+    type: "object",
+    properties: {
+      peer_name: { type: "string", description: "Name of the peer to wake up (as in peers.json)" }
+    },
+    required: ["peer_name"]
+  },
+  async execute(args) {
+    const { sendWakeup } = await import("./dns-wakeup-27M7D2MR.js");
+    const { loadPeerConfig } = await import("./peer-config-VK6EDLN5.js");
+    const peerName = args.peer_name?.trim();
+    if (!peerName) return JSON.stringify({ error: "peer_name required" });
+    const config = loadPeerConfig();
+    const peer = config.peers[peerName];
+    if (!peer) return JSON.stringify({ error: `Unknown peer: ${peerName}` });
+    const udpPort = peer.udpPort ?? 5353;
+    sendWakeup(config.self.name, peer.host, udpPort, peer.token);
+    return JSON.stringify({ ok: true, message: `Wake-up sent to ${peerName}. Expect callback within seconds.` });
+  }
+};
+var ircSendTool = {
+  name: "irc_send",
+  description: "Send a message to an IRC channel (e.g. #bridges)",
+  parameters: {
+    channel: { type: "string", description: "IRC channel (e.g. #bridges)" },
+    message: { type: "string", description: "Message text to send" }
+  },
+  execute: async (args) => {
+    if (!_ircSend) return JSON.stringify({ error: "IRC adapter not connected" });
+    const channel = args["channel"] ?? "";
+    const message = args["message"] ?? "";
+    if (!channel || !message) return JSON.stringify({ error: "channel and message are required" });
+    _ircSend(channel, message);
+    return JSON.stringify({ ok: true, channel, sent: message.length + " chars" });
+  }
+};
+var secretGetTool = {
+  name: "secret_get",
+  description: "Retrieve a secret from ~/.abtars/secret/. For env-var secrets (no extension), returns the value. For files (with extension like .json), returns the full decrypted content. NEVER echo the value to the user.",
+  parameters: {
+    properties: {
+      name: { type: "string", description: "Exact filename in secret/ dir (e.g. 'OPENROUTER_API_KEY', 'x-cookies.json')" }
+    },
+    required: ["name"]
+  },
+  execute: async (args) => {
+    const name = args.name?.trim();
+    if (!name) return JSON.stringify({ error: "name is required" });
+    try {
+      const { join: join3 } = await import("node:path");
+      const { homedir: homedir3 } = await import("node:os");
+      const { readFileSync: readFileSync2, existsSync: existsSync2 } = await import("node:fs");
+      const { createDecipheriv, hkdfSync } = await import("node:crypto");
+      const { loadKey } = await import("abmind");
+      const secretPath = join3(homedir3(), ".abtars", "secret", name);
+      if (!existsSync2(secretPath)) return JSON.stringify({ error: `secret '${name}' not found` });
+      const raw = readFileSync2(secretPath, "utf-8").trim();
+      if (!raw) return JSON.stringify({ error: `secret '${name}' is empty` });
+      let value;
+      if (raw.startsWith("ENC:")) {
+        const master = loadKey();
+        const key = Buffer.from(hkdfSync("sha256", master, "", "abtars-secrets-files-v1", 32));
+        const buf = Buffer.from(raw.slice(4), "base64");
+        const d = createDecipheriv("aes-256-gcm", key, buf.subarray(1, 13));
+        d.setAuthTag(buf.subarray(buf.length - 16));
+        value = d.update(buf.subarray(13, buf.length - 16), void 0, "utf-8") + d.final("utf-8");
+      } else {
+        value = raw;
+      }
+      if (!name.includes(".")) {
+        process.env[name] = value;
+        return JSON.stringify({ ok: true, env_var: `$${name}`, hint: `Use $${name} in commands. NEVER print or echo the value.` });
+      }
+      return JSON.stringify({ ok: true, content: value });
+    } catch (err) {
+      return JSON.stringify({ error: `secret_get failed: ${err instanceof Error ? err.message : String(err)}` });
+    }
+  }
+};
+var ALL_TOOLS = [bashTool, memoryStoreTool, memoryRecallTool, memoryEditTool, webBrowseTool, todoTool, taskTool, sendDocumentTool, peerSessionTool, peerWakeupTool, ircSendTool, secretGetTool, skillCreateTool, skillUpdateTool, skillPatchTool, skillRemoveTool, mcpTool, ...getDelegationTools()];
+function getToolDefinitions() {
+  return ALL_TOOLS;
+}
+function getToolSchemas(policy) {
+  const tools = policy ? ALL_TOOLS.filter((t) => checkTool(t.name, policy).allowed) : ALL_TOOLS;
+  return tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+}
+function checkSkillRead(toolName, args) {
+  if (toolName !== "execute_bash") return;
+  const cmd = args["command"] ?? "";
+  if (cmd.includes("/.abtars/skills/") && cmd.includes("/SKILL.md")) {
+    const match = cmd.match(/\/.abtars\/skills\/[^/]+\/([^/]+)\/SKILL\.md/);
+    if (match) bumpRead(match[1]);
+  }
+}
+async function executeToolCall(name, args, context) {
+  if (context?.sandboxPolicy) {
+    const toolCheck = checkTool(name, context.sandboxPolicy);
+    if (!toolCheck.allowed) {
+      const available = ALL_TOOLS.filter((t) => checkTool(t.name, context.sandboxPolicy).allowed).map((t) => t.name);
+      auditDeny(name, void 0, "session", toolCheck.reason);
+      return JSON.stringify({ error: `Tool '${name}' not available in this session`, available_tools: available, reason: "peer_sandbox" });
+    }
+    const filePath = args["path"] ?? args["file_path"];
+    if (filePath) {
+      const mode = name.includes("read") || name === "memory_recall" ? "read" : "write";
+      const pathCheck = checkPath(filePath, mode, context.sandboxPolicy);
+      if (!pathCheck.allowed) {
+        auditDeny(name, filePath, "session", pathCheck.reason);
+        return JSON.stringify({ error: pathCheck.reason, reason: "peer_sandbox" });
+      }
+    }
+  }
+  const tool = ALL_TOOLS.find((t) => t.name === name);
+  if (!tool) return JSON.stringify({ error: `Unknown tool: ${name}` });
+  const ts = Date.now();
+  const storeClass = name === "abmind_store" || name === "memory_store" ? parseInt(args.classification ?? args.class ?? "1", 10) : 0;
+  const auditArgs = storeClass >= 2 ? `{"class":${storeClass},"[REDACTED]":true}` : redactSecrets(JSON.stringify(args));
+  audit2({ ts, tool: name, args: auditArgs, userId: context?.userId });
+  try {
+    const result = await tool.execute(args, context);
+    audit2({ ts, tool: name, status: "ok", chars: result.length });
+    checkSkillRead(name, args);
+    return result;
+  } catch (err) {
+    audit2({ ts, tool: name, status: "error", error: err instanceof Error ? err.message : String(err) });
+    throw err;
+  }
+}
+
+export {
+  isBridgeSpawnCommand,
+  setMemoryBackend,
+  setPeerActivityCallback,
+  resetStoreCounter,
+  setEnqueueCron,
+  setIrcSend,
+  setSecretGetDb,
+  setSendDocument,
+  getToolDefinitions,
+  getToolSchemas,
+  executeToolCall
+};
+//# sourceMappingURL=chunk-VVEDVGCR.js.map