negotium 0.1.21 → 0.1.23

package/dist/hosted-agent.js

@@ -683,248 +683,6 @@ function isSensitivePath(filePath) {
   return false;
 }
 
-// ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync5 } from "fs";
-import { join as join5 } from "path";
-
-// ../../packages/core/src/storage/sqlite.ts
-var isBun = typeof process.versions.bun === "string";
-var Database;
-if (isBun) {
-  ({ Database } = await import("bun:sqlite"));
-} else {
-  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
-  const { DatabaseSync } = await import(nodeSqliteSpecifier);
-
-  class NodeDatabase {
-    #db;
-    constructor(path, options = {}) {
-      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
-    }
-    query(sql) {
-      return this.#db.prepare(sql);
-    }
-    prepare(sql) {
-      return this.#db.prepare(sql);
-    }
-    exec(sql) {
-      this.#db.exec(sql);
-    }
-    run(sql, ...params) {
-      return this.#db.prepare(sql).run(...params);
-    }
-    transaction(fn) {
-      const run = (begin) => (...args) => {
-        this.#db.exec(begin);
-        try {
-          const result = fn(...args);
-          this.#db.exec("COMMIT");
-          return result;
-        } catch (err) {
-          this.#db.exec("ROLLBACK");
-          throw err;
-        }
-      };
-      const tx = run("BEGIN");
-      tx.deferred = run("BEGIN DEFERRED");
-      tx.immediate = run("BEGIN IMMEDIATE");
-      tx.exclusive = run("BEGIN EXCLUSIVE");
-      return tx;
-    }
-    close() {
-      this.#db.close();
-    }
-  }
-  Database = NodeDatabase;
-}
-
-// ../../packages/core/src/storage/vault-crypto.ts
-import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes2 } from "crypto";
-var ENVELOPE_PREFIX = "otium-vault:v1:";
-var IV_BYTES = 12;
-var KEY_BYTES = 32;
-function encryptionKey(masterKey = VAULT_MASTER_KEY) {
-  return createHash("sha256").update("otium-vault-value-v1\x00", "utf8").update(masterKey, "utf8").digest().subarray(0, KEY_BYTES);
-}
-function aad(userId, key) {
-  return Buffer.from(`${userId}\x00${key.toUpperCase()}`, "utf8");
-}
-function isEncryptedVaultValue(value) {
-  return value.startsWith(ENVELOPE_PREFIX);
-}
-function encryptVaultValue(userId, key, value, masterKey = VAULT_MASTER_KEY) {
-  const iv = randomBytes2(IV_BYTES);
-  const cipher = createCipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
-  cipher.setAAD(aad(userId, key));
-  const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
-}
-function decryptVaultValue(userId, key, storedValue, masterKey = VAULT_MASTER_KEY) {
-  if (!isEncryptedVaultValue(storedValue)) {
-    return { value: storedValue, legacyPlaintext: true };
-  }
-  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
-  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
-  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
-    throw new Error("Invalid encrypted vault value");
-  }
-  const iv = Buffer.from(ivPart, "base64url");
-  const ciphertext = Buffer.from(ciphertextPart, "base64url");
-  const tag = Buffer.from(tagPart, "base64url");
-  if (iv.length !== IV_BYTES || tag.length !== 16) {
-    throw new Error("Invalid encrypted vault value");
-  }
-  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
-  decipher.setAAD(aad(userId, key));
-  decipher.setAuthTag(tag);
-  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
-}
-
-// ../../packages/core/src/storage/vault.ts
-var vaultDb;
-var vaultMasterKey = VAULT_MASTER_KEY;
-function initializeVaultDatabase(database) {
-  database.exec("PRAGMA journal_mode = WAL");
-  database.exec("PRAGMA busy_timeout = 5000");
-  database.exec(`
-  CREATE TABLE IF NOT EXISTS vault (
-    user_id     TEXT    NOT NULL,
-    key         TEXT    NOT NULL,
-    value       TEXT    NOT NULL,
-    description TEXT    NOT NULL DEFAULT '',
-    PRIMARY KEY (user_id, key)
-  )
-  `);
-  {
-    const cols = database.prepare("PRAGMA table_info(vault)").all();
-    const uid = cols.find((c) => c.name === "user_id");
-    if (uid && uid.type.toUpperCase() === "INTEGER") {
-      database.exec("BEGIN");
-      database.exec(`
-      CREATE TABLE vault_migrated (
-        user_id     TEXT    NOT NULL,
-        key         TEXT    NOT NULL,
-        value       TEXT    NOT NULL,
-        description TEXT    NOT NULL DEFAULT '',
-        PRIMARY KEY (user_id, key)
-      )
-    `);
-      database.exec("INSERT INTO vault_migrated SELECT CAST(user_id AS TEXT), key, value, description FROM vault");
-      database.exec("DROP TABLE vault");
-      database.exec("ALTER TABLE vault_migrated RENAME TO vault");
-      database.exec("COMMIT");
-    }
-  }
-}
-function openVaultDatabase(dataDir) {
-  const path = join5(dataDir, "vault.db");
-  mkdirSync5(dataDir, { recursive: true });
-  const database = new Database(path, { create: true });
-  chmodSync2(path, 384);
-  initializeVaultDatabase(database);
-  return database;
-}
-function activeVaultDatabase() {
-  if (!vaultDb)
-    vaultDb = openVaultDatabase(DATA_DIR);
-  return vaultDb;
-}
-var VAULT_VALUE_MAX_BYTES = 64 * 1024;
-function normalizeVaultKey(key) {
-  return key.trim().toUpperCase();
-}
-function decryptRow(userId, key, storedValue) {
-  const database = activeVaultDatabase();
-  const decoded = decryptVaultValue(userId, key, storedValue, vaultMasterKey);
-  if (decoded.legacyPlaintext) {
-    database.prepare("UPDATE vault SET value = ? WHERE user_id = ? AND key = ? AND value = ?").run(encryptVaultValue(userId, key, decoded.value, vaultMasterKey), userId, key, storedValue);
-  }
-  return decoded.value;
-}
-function vaultListWithValues(userId) {
-  const rows = activeVaultDatabase().prepare("SELECT key, description, value FROM vault WHERE user_id = ? ORDER BY key").all(userId);
-  return rows.map((row) => ({
-    key: row.key,
-    description: row.description,
-    value: decryptRow(userId, row.key, row.value)
-  }));
-}
-function vaultList(userId) {
-  return activeVaultDatabase().prepare("SELECT key, description FROM vault WHERE user_id = ? ORDER BY key").all(userId);
-}
-function vaultSubstituteDetailed(userId, text) {
-  const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
-  const usedKeys = new Set;
-  const substituted = text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
-    const key = normalizeVaultKey(rawKey);
-    const value = entries.get(key);
-    if (value === undefined)
-      return match;
-    usedKeys.add(key);
-    return value;
-  });
-  return { text: substituted, usedKeys: [...usedKeys] };
-}
-function valueReferencesVaultKey(userId, value) {
-  const keys = new Set(vaultList(userId).map((entry) => entry.key));
-  const visit = (candidate) => {
-    if (typeof candidate === "string") {
-      for (const match of candidate.matchAll(/\{\{([^}]+)\}\}/g)) {
-        if (keys.has(normalizeVaultKey(match[1] ?? "")))
-          return true;
-      }
-      return false;
-    }
-    if (Array.isArray(candidate))
-      return candidate.some(visit);
-    if (candidate && typeof candidate === "object") {
-      return Object.values(candidate).some(visit);
-    }
-    return false;
-  };
-  return visit(value);
-}
-function encodedSecretForms(value) {
-  const forms = new Set([
-    value,
-    encodeURIComponent(value),
-    Buffer.from(value, "utf8").toString("base64"),
-    Buffer.from(value, "utf8").toString("base64url"),
-    Buffer.from(value, "utf8").toString("hex")
-  ]);
-  forms.delete("");
-  return [...forms].sort((a, b) => b.length - a.length);
-}
-function redactVaultSecrets(userId, text) {
-  const candidates = vaultListWithValues(userId).flatMap((entry) => encodedSecretForms(entry.value).map((form) => ({ form, key: entry.key }))).sort((a, b) => b.form.length - a.form.length || a.key.localeCompare(b.key));
-  if (candidates.length === 0)
-    return text;
-  const candidatesByFirstCharacter = new Map;
-  for (const candidate of candidates) {
-    const first = candidate.form[0];
-    if (!first)
-      continue;
-    const bucket = candidatesByFirstCharacter.get(first) ?? [];
-    bucket.push(candidate);
-    candidatesByFirstCharacter.set(first, bucket);
-  }
-  let redacted = "";
-  let offset = 0;
-  while (offset < text.length) {
-    const match = candidatesByFirstCharacter.get(text[offset] ?? "")?.find((candidate) => text.startsWith(candidate.form, offset));
-    if (!match) {
-      redacted += text[offset];
-      offset += 1;
-      continue;
-    }
-    redacted += `[REDACTED:${match.key}]`;
-    offset += match.form.length;
-  }
-  return redacted;
-}
-
 // ../../packages/core/src/agents/vault-tool-policy.ts
 var SENSITIVE_RUNTIME_NAMES = [
   "vault.db",
@@ -932,6 +690,15 @@ var SENSITIVE_RUNTIME_NAMES = [
   "runtime-mcp-secret",
   "sessions.db"
 ];
+var DIRECT_VAULT_EXECUTION_TOOLS = new Set(["Bash", "WebFetch"]);
+function leafToolName(toolName) {
+  const parts = toolName.split("__");
+  return parts.at(-1) ?? toolName;
+}
+function shouldSubstituteVaultToolInput(toolName) {
+  const leaf = leafToolName(toolName);
+  return leaf.startsWith("browser_") || DIRECT_VAULT_EXECUTION_TOOLS.has(leaf);
+}
 function createVaultToolPolicy(host) {
   function isVaultBrokerTool(toolName) {
     return toolName.includes("vault_run") || toolName.includes("vault_http_request");
@@ -951,11 +718,14 @@ function createVaultToolPolicy(host) {
     return false;
   }
   function shouldRedirectVaultTool(userId, toolName, input) {
-    return !isVaultBrokerTool(toolName) && host.valueReferencesVaultKey(userId, input);
+    return false;
   }
   return { isVaultBrokerTool, referencesRuntimeSecretStorage, shouldRedirectVaultTool };
 }
-var defaultVaultToolPolicy = createVaultToolPolicy({ isSensitivePath, valueReferencesVaultKey });
+var defaultVaultToolPolicy = createVaultToolPolicy({
+  isSensitivePath,
+  valueReferencesVaultKey: () => false
+});
 var isVaultBrokerTool = defaultVaultToolPolicy.isVaultBrokerTool;
 var referencesRuntimeSecretStorage = defaultVaultToolPolicy.referencesRuntimeSecretStorage;
 var shouldRedirectVaultTool = defaultVaultToolPolicy.shouldRedirectVaultTool;
@@ -1011,7 +781,7 @@ function peerSessionBridgeIpcEnv() {
 
 // ../../packages/core/src/platform/background-bash/manager.ts
 import { execFileSync, spawn } from "child_process";
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 
 // ../../packages/core/src/platform/delay.ts
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -1039,8 +809,8 @@ function createBackgroundBashManager(options = {}) {
   const usedPorts = new Set;
   const spawning = new Map;
   const knownContexts = new Map;
-  const runtimeCapability = options.capability ?? randomBytes3(32).toString("hex");
-  const runtimeServerId = options.serverId ?? randomBytes3(16).toString("hex");
+  const runtimeCapability = options.capability ?? randomBytes2(32).toString("hex");
+  const runtimeServerId = options.serverId ?? randomBytes2(16).toString("hex");
   const serverFile = options.serverFile ?? BACKGROUND_BASH_SERVER;
   const basePort = options.basePort ?? BG_BASH_BASE_PORT;
   const maxPort = options.maxPort ?? BG_BASH_MAX_PORT;
@@ -1468,7 +1238,9 @@ var MCP_CATALOG = {
   vault: {
     ...commonRuntimeMcpPolicy("vault"),
     build({ userId, agent }) {
-      const args = [`--user-id=${userId}`, "--list-only=true"];
+      const args = [`--user-id=${userId}`];
+      if (agent !== "codex")
+        args.push("--list-only=true");
       return buildStdioMcpServer(agent, VAULT_SERVER, args);
     }
   }
@@ -1686,6 +1458,226 @@ function getMcpServersForQuery(opts) {
   });
 }
 
+// ../../packages/core/src/storage/vault.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5 } from "fs";
+import { join as join5 } from "path";
+
+// ../../packages/core/src/storage/sqlite.ts
+var isBun = typeof process.versions.bun === "string";
+var Database;
+if (isBun) {
+  ({ Database } = await import("bun:sqlite"));
+} else {
+  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
+  const { DatabaseSync } = await import(nodeSqliteSpecifier);
+
+  class NodeDatabase {
+    #db;
+    constructor(path, options = {}) {
+      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
+    }
+    query(sql) {
+      return this.#db.prepare(sql);
+    }
+    prepare(sql) {
+      return this.#db.prepare(sql);
+    }
+    exec(sql) {
+      this.#db.exec(sql);
+    }
+    run(sql, ...params) {
+      return this.#db.prepare(sql).run(...params);
+    }
+    transaction(fn) {
+      const run = (begin) => (...args) => {
+        this.#db.exec(begin);
+        try {
+          const result = fn(...args);
+          this.#db.exec("COMMIT");
+          return result;
+        } catch (err) {
+          this.#db.exec("ROLLBACK");
+          throw err;
+        }
+      };
+      const tx = run("BEGIN");
+      tx.deferred = run("BEGIN DEFERRED");
+      tx.immediate = run("BEGIN IMMEDIATE");
+      tx.exclusive = run("BEGIN EXCLUSIVE");
+      return tx;
+    }
+    close() {
+      this.#db.close();
+    }
+  }
+  Database = NodeDatabase;
+}
+
+// ../../packages/core/src/storage/vault-crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes3 } from "crypto";
+var ENVELOPE_PREFIX = "otium-vault:v1:";
+var IV_BYTES = 12;
+var KEY_BYTES = 32;
+function encryptionKey(masterKey = VAULT_MASTER_KEY) {
+  return createHash("sha256").update("otium-vault-value-v1\x00", "utf8").update(masterKey, "utf8").digest().subarray(0, KEY_BYTES);
+}
+function aad(userId, key) {
+  return Buffer.from(`${userId}\x00${key.toUpperCase()}`, "utf8");
+}
+function isEncryptedVaultValue(value) {
+  return value.startsWith(ENVELOPE_PREFIX);
+}
+function encryptVaultValue(userId, key, value, masterKey = VAULT_MASTER_KEY) {
+  const iv = randomBytes3(IV_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
+  cipher.setAAD(aad(userId, key));
+  const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
+}
+function decryptVaultValue(userId, key, storedValue, masterKey = VAULT_MASTER_KEY) {
+  if (!isEncryptedVaultValue(storedValue)) {
+    return { value: storedValue, legacyPlaintext: true };
+  }
+  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
+  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
+  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const iv = Buffer.from(ivPart, "base64url");
+  const ciphertext = Buffer.from(ciphertextPart, "base64url");
+  const tag = Buffer.from(tagPart, "base64url");
+  if (iv.length !== IV_BYTES || tag.length !== 16) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
+  decipher.setAAD(aad(userId, key));
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
+}
+
+// ../../packages/core/src/storage/vault.ts
+var vaultDb;
+var vaultMasterKey = VAULT_MASTER_KEY;
+function initializeVaultDatabase(database) {
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA busy_timeout = 5000");
+  database.exec(`
+  CREATE TABLE IF NOT EXISTS vault (
+    user_id     TEXT    NOT NULL,
+    key         TEXT    NOT NULL,
+    value       TEXT    NOT NULL,
+    description TEXT    NOT NULL DEFAULT '',
+    PRIMARY KEY (user_id, key)
+  )
+  `);
+  {
+    const cols = database.prepare("PRAGMA table_info(vault)").all();
+    const uid = cols.find((c) => c.name === "user_id");
+    if (uid && uid.type.toUpperCase() === "INTEGER") {
+      database.exec("BEGIN");
+      database.exec(`
+      CREATE TABLE vault_migrated (
+        user_id     TEXT    NOT NULL,
+        key         TEXT    NOT NULL,
+        value       TEXT    NOT NULL,
+        description TEXT    NOT NULL DEFAULT '',
+        PRIMARY KEY (user_id, key)
+      )
+    `);
+      database.exec("INSERT INTO vault_migrated SELECT CAST(user_id AS TEXT), key, value, description FROM vault");
+      database.exec("DROP TABLE vault");
+      database.exec("ALTER TABLE vault_migrated RENAME TO vault");
+      database.exec("COMMIT");
+    }
+  }
+}
+function openVaultDatabase(dataDir) {
+  const path = join5(dataDir, "vault.db");
+  mkdirSync5(dataDir, { recursive: true });
+  const database = new Database(path, { create: true });
+  chmodSync2(path, 384);
+  initializeVaultDatabase(database);
+  return database;
+}
+function activeVaultDatabase() {
+  if (!vaultDb)
+    vaultDb = openVaultDatabase(DATA_DIR);
+  return vaultDb;
+}
+var VAULT_VALUE_MAX_BYTES = 64 * 1024;
+function normalizeVaultKey(key) {
+  return key.trim().toUpperCase();
+}
+function decryptRow(userId, key, storedValue) {
+  const database = activeVaultDatabase();
+  const decoded = decryptVaultValue(userId, key, storedValue, vaultMasterKey);
+  if (decoded.legacyPlaintext) {
+    database.prepare("UPDATE vault SET value = ? WHERE user_id = ? AND key = ? AND value = ?").run(encryptVaultValue(userId, key, decoded.value, vaultMasterKey), userId, key, storedValue);
+  }
+  return decoded.value;
+}
+function vaultListWithValues(userId) {
+  const rows = activeVaultDatabase().prepare("SELECT key, description, value FROM vault WHERE user_id = ? ORDER BY key").all(userId);
+  return rows.map((row) => ({
+    key: row.key,
+    description: row.description,
+    value: decryptRow(userId, row.key, row.value)
+  }));
+}
+function vaultSubstituteDetailed(userId, text) {
+  const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
+  const usedKeys = new Set;
+  const substituted = text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+    const key = normalizeVaultKey(rawKey);
+    const value = entries.get(key);
+    if (value === undefined)
+      return match;
+    usedKeys.add(key);
+    return value;
+  });
+  return { text: substituted, usedKeys: [...usedKeys] };
+}
+function encodedSecretForms(value) {
+  const forms = new Set([
+    value,
+    encodeURIComponent(value),
+    Buffer.from(value, "utf8").toString("base64"),
+    Buffer.from(value, "utf8").toString("base64url"),
+    Buffer.from(value, "utf8").toString("hex")
+  ]);
+  forms.delete("");
+  return [...forms].sort((a, b) => b.length - a.length);
+}
+function redactVaultSecrets(userId, text) {
+  const candidates = vaultListWithValues(userId).flatMap((entry) => encodedSecretForms(entry.value).map((form) => ({ form, key: entry.key }))).sort((a, b) => b.form.length - a.form.length || a.key.localeCompare(b.key));
+  if (candidates.length === 0)
+    return text;
+  const candidatesByFirstCharacter = new Map;
+  for (const candidate of candidates) {
+    const first = candidate.form[0];
+    if (!first)
+      continue;
+    const bucket = candidatesByFirstCharacter.get(first) ?? [];
+    bucket.push(candidate);
+    candidatesByFirstCharacter.set(first, bucket);
+  }
+  let redacted = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const match = candidatesByFirstCharacter.get(text[offset] ?? "")?.find((candidate) => text.startsWith(candidate.form, offset));
+    if (!match) {
+      redacted += text[offset];
+      offset += 1;
+      continue;
+    }
+    redacted += `[REDACTED:${match.key}]`;
+    offset += match.form.length;
+  }
+  return redacted;
+}
+
 // ../../packages/core/src/agents/execution-host.ts
 var defaultHost = {
   getMcpServersForQuery,
@@ -1792,7 +1784,9 @@ var CLAUDE_DEFAULT_DISALLOWED_TOOLS = [
   "TaskGet"
 ];
 var CLAUDE_NATIVE_AGENT_TOOLS = ["Task", "Agent", "TaskOutput", "TaskStop"];
-function substituteClaudeToolInput(userId, input) {
+function substituteClaudeToolInput(userId, toolName, input) {
+  if (!shouldSubstituteVaultToolInput(toolName))
+    return input;
   return deepMapStrings(input, (value) => substituteHostedSecrets(userId, value));
 }
 function buildClaudeDisallowedTools(extra = undefined) {
@@ -2033,7 +2027,7 @@ async function* claudeProvider(opts) {
                 };
               }
               const userId = opts.userId ?? "";
-              const withVault = substituteClaudeToolInput(userId, tool_input);
+              const withVault = substituteClaudeToolInput(userId, tool_name, tool_input);
               if (JSON.stringify(withVault) === JSON.stringify(tool_input)) {
                 return { continue: true };
               }
@@ -2265,7 +2259,7 @@ import { createRequire } from "module";
 import { dirname as dirname4, join as join6 } from "path";
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.1.21";
+var NEGOTIUM_VERSION = "0.1.23";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 var NEGOTIUM_MODEL_CATALOG = "negotium-model-catalog.json";
@@ -3273,10 +3267,12 @@ function buildMaestroDisallowedTools(callerDisallowedTools = []) {
 function buildVaultHook(userId) {
   return {
     name: "vault-guard",
-    pre({ input }) {
+    pre({ toolName, input }) {
       if (referencesHostedSecretStorage(input)) {
         return { decision: "block", error: "Runtime secret storage access is not permitted" };
       }
+      if (!shouldSubstituteVaultToolInput(toolName))
+        return { decision: "allow" };
       const substituted = deepMapStrings(input, (value) => substituteHostedSecrets(userId, value));
       return JSON.stringify(substituted) === JSON.stringify(input) ? { decision: "allow" } : { decision: "modify", input: substituted };
     },
@@ -3415,4 +3411,4 @@ export {
   buildClaudeDisallowedTools
 };
 
-//# debugId=8285C4044AB0E6D764756E2164756E21
+//# debugId=CC21E70C5AF6A3D464756E2164756E21