@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/repertoire/guardrails.js

@@ -37,8 +37,11 @@ exports.OURO_CLI_TRUST_MANIFEST = void 0;
 exports.guardInvocation = guardInvocation;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
-const types_1 = require("../mind/friends/types");
+const path = __importStar(require("node:path"));
+const friends_1 = require("@ouro.bot/friends");
+const shell_quote_1 = require("shell-quote");
 const runtime_1 = require("../nerves/runtime");
+const store_1 = require("../commerce/store");
 const deny = (reason) => ({ allowed: false, reason });
 const allow = { allowed: true };
 // --- reason templates ---
@@ -47,6 +50,7 @@ const REASONS = {
     readBeforeEdit: "i need to read that file first before i can edit it.",
     readBeforeOverwrite: "i need to read that file first before i can overwrite it.",
     protectedPath: "that path is protected — i can read it but not modify it.",
+    psychePath: "my psyche files ship from the repository through a pull request and the replay gate; i can read them but not change them. i file the change request with Claude Code instead.",
     destructiveCommand: "that command is too dangerous to run — it could cause irreversible damage.",
     // Trust reasons (vary by relationship)
     needsTrust: "i'd need a closer friend to vouch for you before i can do that.",
@@ -55,17 +59,45 @@ const REASONS = {
 // --- read-only tools that never need guardrails ---
 const READ_ONLY_TOOLS = new Set(["read_file", "glob", "grep"]);
 // --- protected path detection ---
-const PROTECTED_PATH_SEGMENTS = [".git/"];
-function getProtectedAbsolutePrefixes() {
-    return [`${os.homedir()}/.agentsecrets/`];
+const PROTECTED_PATH_SEGMENTS = [
+    ".git/",
+    ".ouro-cli/vault-unlock/",
+    ".ouro-cli/vault-unlock-dpapi/",
+    "state/policy/",
+    // The pre-trust-directory home of the escalation grants; the file is no longer read, and a model must not recreate it.
+    "state/a2a/escalation-grants.json",
+    "state/outbox/",
+    "state/reports/",
+];
+const PROTECTED_FILENAMES = ["agent.json", "tool-profiles.json"];
+/** The agent's psyche folder ships only from the repository (a pull request and the replay gate), so no tool writes into it. */
+function isPsychePath(filePath, agentRoot) {
+    if (!agentRoot || !filePath)
+        return false;
+    const psyche = path.resolve(agentRoot, "psyche");
+    const target = path.resolve(agentRoot, filePath);
+    return target === psyche || target.startsWith(`${psyche}${path.sep}`);
+}
+/**
+ * The friends store (`friends/` under the agent root) is written by the harness's own code, which the model's file tools and
+ * shell redirects must not reach: a model talked into editing a record could rewrite trust, admission or a legacy grant.
+ * Scoped to this agent's root, so a project directory that happens to be named `friends` stays editable. Defence in depth
+ * only: a shell can still write anywhere its uid can, which is why delegated-command authority lives outside the bundle.
+ */
+function isFriendsStorePath(filePath, agentRoot) {
+    if (!agentRoot || !filePath)
+        return false;
+    const store = path.resolve(agentRoot, "friends");
+    const target = path.resolve(agentRoot, filePath);
+    return target === store || target.startsWith(`${store}${path.sep}`);
 }
 function isProtectedPath(filePath) {
     for (const segment of PROTECTED_PATH_SEGMENTS) {
         if (filePath.includes(`/${segment}`) || filePath.startsWith(segment))
             return true;
     }
-    for (const prefix of getProtectedAbsolutePrefixes()) {
-        if (filePath.startsWith(prefix))
+    for (const name of PROTECTED_FILENAMES) {
+        if (path.basename(filePath) === name)
             return true;
     }
     return false;
@@ -99,6 +131,116 @@ function shellWritesToProtectedPath(command) {
         return true;
     return false;
 }
+// --- the psyche folder in shell commands ---
+// The psyche folder is mounted read-only into the resident at the OS level (the upgrade recreates the container that way). This is the
+// defence in depth in front of that: a shell command that mentions the psyche folder at all runs only if every part of it is
+// a read-only command, because enumerating the ways to write a file (>, >>, tee, cp, mv, sed -i, node -e, python, cd then
+// redirect) is a list the model can always step around.
+const PSYCHE_READ_ONLY_COMMANDS = new Set(["cat", "ls", "head", "tail", "grep", "wc", "sha256sum", "stat", "cd", "pwd"]);
+const SEGMENT_OPERATORS = new Set(["&&", "||", ";", "|"]);
+// --- globs and expansions that could land inside a protected folder ---
+// A word such as /bundle/fr*nds/x.json, /bundle/friend?/x.json or ${F}ends/x.json names no protected folder literally, but the
+// shell could resolve it into one. A word like that counts as mentioning the folder when its directory part can match the folder's
+// path, so the read-only rule below applies to the command.
+const EXPANSION = "\u0001";
+const STABLE_VARIABLES = ["HOME", "TMPDIR", "USER"];
+function neutraliseExpansions(command) {
+    return command.replace(/\$\([^)]*\)|`[^`]*`|\$\{([A-Za-z_]\w*)\}|\$([A-Za-z_]\w*)|\$\{[^}]*\}/g, (_match, braced, plain) => {
+        const name = braced ?? plain;
+        if (name !== undefined && STABLE_VARIABLES.includes(name) && !new RegExp(`\\b${name}=`).test(command) && process.env[name])
+            return process.env[name];
+        return EXPANSION;
+    });
+}
+function wordPattern(word) {
+    const generalised = word.replace(/\{[^}]*\}/g, EXPANSION).replace(/\[[^\]]*\]/g, "?");
+    let source = "";
+    for (const char of generalised)
+        source += char === EXPANSION ? ".*" : char === "*" ? "[^/]*" : char === "?" ? "[^/]" : char.replace(/[.+^$()|\\\]{}[]/g, "\\$&");
+    return new RegExp(`^${source}$`);
+}
+function globOrExpansionCouldReach(command, folder, agentRoot) {
+    const tokens = neutraliseExpansions(command).split(/[\s<>|;&()'"]+/).filter((token) => /[*?[{\u0001]/.test(token));
+    return tokens.some((token) => {
+        const word = token.startsWith("~") ? expandHome(token) : token;
+        const absolute = word.startsWith("/") || word.startsWith(EXPANSION) ? word : `${agentRoot}/${word}`;
+        const dir = absolute.slice(0, Math.max(absolute.lastIndexOf("/"), 0));
+        return wordPattern(absolute).test(folder) || wordPattern(dir).test(folder);
+    });
+}
+function commandMentionsPsyche(command, words, agentRoot) {
+    const psyche = path.resolve(agentRoot, "psyche");
+    if (globOrExpansionCouldReach(command, psyche, agentRoot))
+        return true;
+    if (command.includes(psyche) || words.some((word) => word.includes(psyche)))
+        return true;
+    if (words.some((word) => word === "psyche" || isPsychePath(word, agentRoot)))
+        return true;
+    // A relative "psyche/..." inside code or a quoted argument, when this agent has such a folder.
+    return /(?:^|[\s'"=(])psyche\//.test(command) && fs.existsSync(psyche);
+}
+/**
+ * The shared rule: when a shell command mentions a protected folder at all, it runs only if every part of it is a read-only
+ * command. The mention test is the only thing that differs between folders.
+ */
+function protectedFolderShellWriteRefused(command, mentions) {
+    const entries = (0, shell_quote_1.parse)(command);
+    const words = entries.filter((entry) => typeof entry === "string");
+    if (!mentions(words))
+        return false;
+    // Substitution, heredocs and any $VAR or ${VAR} expansion: the shell could build a protected path or a command word we cannot see.
+    if (/\$[({A-Za-z_]|`|<\(|<</.test(command))
+        return true;
+    let expectCommandWord = true;
+    for (const entry of entries) {
+        if (typeof entry === "string") {
+            if (expectCommandWord && !/^\w+=/.test(entry)) {
+                if (!PSYCHE_READ_ONLY_COMMANDS.has(entry))
+                    return true;
+                expectCommandWord = false;
+            }
+            continue;
+        }
+        const op = "op" in entry ? entry.op : "comment";
+        if (SEGMENT_OPERATORS.has(op))
+            expectCommandWord = true;
+        else if (op !== "glob")
+            return true;
+    }
+    return false;
+}
+function psycheShellWriteRefused(command, agentRoot) {
+    if (!agentRoot)
+        return false;
+    return protectedFolderShellWriteRefused(command, (words) => commandMentionsPsyche(command, words, agentRoot));
+}
+// --- the friends store in shell commands ---
+// Same stance as the psyche folder: a command that names this agent's friends store runs only if it is read-only, because a list of
+// the ways to write a file (>, >>, tee, cp, mv, sed -i, node -e, python, cd then redirect, ~ paths) is one the model can step around.
+function expandHome(word) {
+    return word === "~" || word.startsWith("~/") ? path.join(os.homedir(), word.slice(1)) : word;
+}
+function commandMentionsFriendsStore(command, words, agentRoot) {
+    if (globOrExpansionCouldReach(command, path.resolve(agentRoot, "friends"), agentRoot))
+        return true;
+    // Only path-shaped words resolve against the store: an ordinary word such as "friends" in prose is not a path.
+    if (words.some((word) => word.includes("/") && isFriendsStorePath(expandHome(word), agentRoot)))
+        return true;
+    // A bare `friends` names the store only as the target of a cd; elsewhere it is an ordinary word ("my friends are kind").
+    if (words.some((word, index) => word.startsWith("friends/") || (word === "friends" && words[index - 1] === "cd")))
+        return true;
+    // A variable or substitution in front of the path ($BUNDLE/friends/x.json): the folder name is still in the command.
+    if (/\$[({A-Za-z_]|`/.test(command) && /(?:^|[\/\s'"=])friends(?:$|[\/\s'"])/.test(command))
+        return true;
+    // An absolute or relative path inside code or a quoted argument, such as node -e "...'/bundle/friends/x.json'...".
+    const store = path.resolve(agentRoot, "friends");
+    return command.includes(store) || /(?:^|[\s'"=(])friends\//.test(command);
+}
+function friendsShellWriteRefused(command, agentRoot) {
+    if (!agentRoot)
+        return false;
+    return protectedFolderShellWriteRefused(command, (words) => commandMentionsFriendsStore(command, words, agentRoot));
+}
 // --- structural guardrail checks (always on, all trust levels) ---
 function checkReadBeforeWrite(toolName, args, context) {
     if (toolName === "edit_file") {
@@ -127,21 +269,27 @@ function checkDestructiveShellPatterns(toolName, args) {
     }
     return allow;
 }
-function checkProtectedPaths(toolName, args) {
+function checkProtectedPaths(toolName, args, context) {
     if (toolName === "write_file" || toolName === "edit_file") {
         const filePath = args.path || "";
-        if (isProtectedPath(filePath))
+        if (isPsychePath(filePath, context.agentRoot))
+            return deny(REASONS.psychePath);
+        if (isProtectedPath(filePath) || isFriendsStorePath(filePath, context.agentRoot))
             return deny(REASONS.protectedPath);
     }
     if (toolName === "shell") {
         const command = args.command || "";
+        if (psycheShellWriteRefused(command, context.agentRoot))
+            return deny(REASONS.psychePath);
+        if (friendsShellWriteRefused(command, context.agentRoot))
+            return deny(REASONS.protectedPath);
         if (shellWritesToProtectedPath(command))
             return deny(REASONS.protectedPath);
     }
     return allow;
 }
 function checkStructuralGuardrails(toolName, args, context) {
-    const protectedResult = checkProtectedPaths(toolName, args);
+    const protectedResult = checkProtectedPaths(toolName, args, context);
     if (!protectedResult.allowed)
         return protectedResult;
     const destructiveResult = checkDestructiveShellPatterns(toolName, args);
@@ -155,18 +303,15 @@ exports.OURO_CLI_TRUST_MANIFEST = {
     whoami: "acquaintance",
     changelog: "acquaintance",
     "session list": "acquaintance",
-    "task board": "friend",
-    "task create": "friend",
-    "task update": "friend",
-    "task show": "friend",
-    "task actionable": "friend",
-    "task deps": "friend",
-    "task sessions": "friend",
     "friend list": "friend",
     "friend show": "friend",
     "friend create": "friend",
     "friend update": "family",
-    "reminder create": "friend",
+    // Linking and merging change who the agent believes someone is: family only.
+    "friend link": "family",
+    "friend unlink": "family",
+    "friend merge": "family",
+    "friend dedupe": "family",
     "config model": "friend",
     "config models": "friend",
     "mcp list": "acquaintance",
@@ -201,7 +346,8 @@ function resolveOuroSubcommand(command) {
     /* v8 ignore next -- bare "ouro" is caught upstream by checkShellTrustGuardrails @preserve */
     if (!afterOuro)
         return null;
-    const tokens = afterOuro.split(/\s+/);
+    // `--agent <name>` may come before the subcommand; it never changes which subcommand runs.
+    const tokens = afterOuro.split(/\s+/).filter((token, index, all) => token !== "--agent" && all[index - 1] !== "--agent");
     const twoWord = tokens.length >= 2 ? `${tokens[0]} ${tokens[1]}` : null;
     // Two-word match first (e.g. "task board"), then one-word (e.g. "whoami")
     if (twoWord && exports.OURO_CLI_TRUST_MANIFEST[twoWord])
@@ -210,6 +356,26 @@ function resolveOuroSubcommand(command) {
         return tokens[0];
     return null;
 }
+// --- MCP server-specific trust rules ---
+const MCP_SERVER_TRUST = {
+    browser: { minTrust: "friend", blockGroupChat: true },
+};
+function checkMcpServerTrust(command, context) {
+    const match = command.match(/^ouro\s+mcp\s+call\s+(\S+)/);
+    if (!match)
+        return allow;
+    const serverName = match[1];
+    const rules = MCP_SERVER_TRUST[serverName];
+    if (!rules)
+        return allow; // no special rules for this server
+    if (!trustLevelSatisfied(rules.minTrust, context.trustLevel ?? "friend")) {
+        return deny(REASONS.needsTrust);
+    }
+    if (rules.blockGroupChat && context.isGroupChat) {
+        return deny("browser tools are only available in 1:1 conversations, not group chats.");
+    }
+    return allow;
+}
 function checkSingleShellCommandTrust(command, trustLevel) {
     const trimmed = command.trim();
     const tokens = trimmed.split(/\s+/);
@@ -261,9 +427,791 @@ function checkWriteTrustGuardrails(toolName, args, context) {
         return allow;
     return deny(REASONS.needsTrustForWrite);
 }
+// --- credential tool trust gating ---
+// Credential write tools: family only
+const CREDENTIAL_FAMILY_TOOLS = new Set([
+    "credential_generate_password", "credential_store", "credential_delete", "vault_setup",
+    // User profile tools: family only
+    "user_profile_store", "user_profile_get", "user_profile_delete",
+    // Payment tools: family only
+    "stripe_create_card", "stripe_deactivate_card", "stripe_list_cards",
+    // Booking tools that involve payment: family only
+    "flight_book", "flight_hold", "flight_cancel",
+]);
+// Credential read tools: friend+
+const CREDENTIAL_TRUSTED_TOOLS = new Set(["credential_get", "credential_list"]);
+// Travel tools: friend+ (weather_lookup accesses vault credentials indirectly;
+// advisory and geocode are public APIs but gated for consistency)
+// Flight search is also friend+ (read-only, no payment)
+const TRAVEL_TRUSTED_TOOLS = new Set(["weather_lookup", "travel_advisory", "geocode_search", "flight_search"]);
+const A2A_TRUSTED_TOOLS = new Set(["a2a_list_peers", "a2a_send_message", "a2a_get_task"]);
+const COMMERCE_FAMILY_TOOLS = new Set(["commerce_checkout_preview", "commerce_checkout_commit", "commerce_receipt_get", "commerce_access_log"]);
+const COMMERCE_AUTHORITY_TOOLS = new Set(["stripe_create_card", "flight_hold", "flight_book"]);
+// The Shepherd tools read the owner's terminals and speak to them through their desktop, so only family may use them.
+// A call with no known trust level fails closed.
+const SHEPHERD_FAMILY_TOOLS = new Set(["shepherd_overview", "shepherd_read", "shepherd_signal", "shepherd_send"]);
+const MAIL_FAMILY_TOOLS = new Set(["mail_screener", "mail_decide", "mail_access_log", "mail_send", "mail_index_refresh"]);
+const MAIL_DELEGATED_READ_TOOLS = new Set(["mail_recent", "mail_search"]);
+function opaqueAnsiShellAtoms(command) {
+    const atoms = [];
+    let inAnsiQuote = false;
+    for (let index = 0; index < command.length;) {
+        if (!inAnsiQuote && command.startsWith("$'", index)) {
+            inAnsiQuote = true;
+            index += 2;
+            continue;
+        }
+        const character = command[index];
+        if (inAnsiQuote && character === "'") {
+            inAnsiQuote = false;
+            index += 1;
+            continue;
+        }
+        if (inAnsiQuote && character === "\\") {
+            const escape = command.slice(index).match(/^\\(?:x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{1,4}|U[0-9a-fA-F]{1,8}|[0-7]{1,3}|c.|.)?/s)[0];
+            atoms.push(null);
+            index += escape.length;
+            continue;
+        }
+        if (!inAnsiQuote && (character === "'" || character === '"')) {
+            index += 1;
+            continue;
+        }
+        if (!inAnsiQuote && character === "\\" && index + 1 < command.length) {
+            atoms.push(command[index + 1]);
+            index += 2;
+            continue;
+        }
+        atoms.push(character);
+        index += 1;
+    }
+    return atoms;
+}
+function shellContainsAmbiguousAnsiMailCacheSync(command) {
+    if (!command.includes("$'"))
+        return false;
+    const expected = ["ouro", "mail", "sync-cache"];
+    let states = new Set(["0:0"]);
+    const crossTokenBoundary = (current) => {
+        const next = new Set(["0:0"]);
+        for (const state of current) {
+            const [tokenIndex, characterIndex] = state.split(":").map(Number);
+            if (characterIndex !== expected[tokenIndex].length)
+                continue;
+            if (tokenIndex === expected.length - 1)
+                return { matched: true, states: next };
+            next.add(`${tokenIndex + 1}:0`);
+        }
+        return { matched: false, states: next };
+    };
+    for (const atom of opaqueAnsiShellAtoms(command)) {
+        if (atom === null) {
+            const next = new Set(states);
+            for (const state of states) {
+                const [tokenIndex, characterIndex] = state.split(":").map(Number);
+                if (characterIndex >= 0 && characterIndex < expected[tokenIndex].length) {
+                    next.add(`${tokenIndex}:${characterIndex + 1}`);
+                }
+            }
+            const boundary = crossTokenBoundary(states);
+            if (boundary.matched)
+                return true;
+            states = new Set([...next, ...boundary.states]);
+            continue;
+        }
+        if (/\s|[;&|()`]/.test(atom)) {
+            const boundary = crossTokenBoundary(states);
+            if (boundary.matched)
+                return true;
+            states = boundary.states;
+            continue;
+        }
+        const next = new Set();
+        for (const state of states) {
+            const [tokenIndex, characterIndex] = state.split(":").map(Number);
+            const wanted = expected[tokenIndex]?.[characterIndex];
+            next.add(wanted?.toLowerCase() === atom.toLowerCase() ? `${tokenIndex}:${characterIndex + 1}` : `${tokenIndex}:-1`);
+        }
+        states = next;
+    }
+    return crossTokenBoundary(states).matched;
+}
+const SHELL_COMMAND_BOUNDARIES = new Set(["||", "&&", ";;", "|&", "&", ";", "(", ")", "|", "<("]);
+const SHELL_INTERPRETERS = new Set(["sh", "bash", "zsh"]);
+const SHELL_TOKEN_BOUNDARIES = new Set(["{", "}", "then", "elif", "else", "do"]);
+const SHELL_GRAMMAR_PREFIXES = new Set(["!", "if", "until", "while"]);
+const SHELL_PARAMETER_MARKER = "__OURO_SHELL_PARAMETER_";
+const SHELL_ARRAY_EXPANSION = "__OURO_ARRAY_EXPANSION__";
+function hasUnescapedShellSubstitution(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] === "\\") {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith("$(", index) && !value.startsWith("$((", index))
+            return true;
+        if (value[index] === "`")
+            return true;
+    }
+    return false;
+}
+function stripHereDocBodies(command) {
+    const pending = [];
+    const lines = command.split("\n");
+    return lines.map((sourceLine) => {
+        if (pending.length > 0) {
+            const active = pending[0];
+            const candidate = active.stripTabs ? sourceLine.replace(/^\t+/, "") : sourceLine;
+            if (candidate === active.delimiter) {
+                pending.shift();
+                return "";
+            }
+            if (active.quoted || !hasUnescapedShellSubstitution(sourceLine))
+                return "";
+            return exposeShellSubstitutions(sourceLine).split("\n").slice(1).join("\n");
+        }
+        const pattern = /<<(?!<)(-)?\s*(?:'([^']*)'|"([^"]*)"|\\([^\s;&|]+)|([^\s;&|]+))/g;
+        for (const match of stripShellComments(sourceLine).matchAll(pattern)) {
+            pending.push({
+                stripTabs: match[1] !== undefined,
+                delimiter: match[2] ?? match[3] ?? match[4] ?? match[5],
+                quoted: match[2] !== undefined || match[3] !== undefined || match[4] !== undefined,
+            });
+        }
+        return sourceLine;
+    }).join("\n");
+}
+function stripShellComments(command) {
+    let result = "";
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "single") {
+            result += character + (command[index + 1] ?? "");
+            index += 1;
+            continue;
+        }
+        if (character === "'" && quote !== "double")
+            quote = quote === "single" ? null : "single";
+        else if (character === '"' && quote !== "single")
+            quote = quote === "double" ? null : "double";
+        if (character === "#" && quote === null && (index === 0 || /[\s;&|()]/.test(command[index - 1]))) {
+            const newline = command.indexOf("\n", index);
+            if (newline < 0)
+                break;
+            result += " ".repeat(newline - index) + "\n";
+            index = newline;
+            continue;
+        }
+        result += character;
+    }
+    return result;
+}
+const SHELL_ARRAY_ASSIGNMENT = /([A-Za-z_][A-Za-z0-9_]*)(\+?=)\(([^()\n]*)\)/y;
+const SHELL_INDEXED_ASSIGNMENT = /([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]=("[^"]*"|'[^']*'|[^\s;&|]+)/y;
+const SHELL_SCALAR_ASSIGNMENT = /([A-Za-z_][A-Za-z0-9_]*)=("[^"]*"|'[^']*'|[^\s;&|()]+)/y;
+const SHELL_ARRAY_PARAMETER = /\$\{([A-Za-z_][A-Za-z0-9_]*)\[(@|\*)\]\}/y;
+const SHELL_SCALAR_PARAMETER = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/y;
+function shellMatchAt(pattern, command, index) {
+    pattern.lastIndex = index;
+    return pattern.exec(command);
+}
+function shellAssignmentPosition(command, index) {
+    let previous = index - 1;
+    while (previous >= 0 && /[ \t]/.test(command[previous]))
+        previous -= 1;
+    return previous < 0 || /[;&|()\n]/.test(command[previous]);
+}
+function parseShellWords(value) {
+    if (hasUnescapedShellSubstitution(value) || /(^|[^\\])\$(?!['"])/.test(value))
+        return undefined;
+    try {
+        const entries = (0, shell_quote_1.parse)(value);
+        if (entries.some((entry) => typeof entry !== "string"))
+            return undefined;
+        return entries;
+    }
+    catch {
+        return undefined;
+    }
+}
+function shellAssignmentPersists(command, endIndex) {
+    let next = endIndex;
+    while (next < command.length && /[ \t]/.test(command[next]))
+        next += 1;
+    return next === command.length || /[;&|\n]/.test(command[next]);
+}
+function shellUnquotedFields(values) {
+    const fields = values.flatMap((value) => value.split(/\s+/).filter(Boolean));
+    return fields.some((field) => /[*?[]/.test(field)) ? SHELL_ARRAY_EXPANSION : (0, shell_quote_1.quote)(fields);
+}
+function doubleQuotedFragment(value) {
+    if (hasUnescapedShellSubstitution(value))
+        return undefined;
+    try {
+        const parsed = (0, shell_quote_1.parse)(`"${value}"`);
+        return parsed.length === 1 && typeof parsed[0] === "string" ? parsed[0] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function closingDoubleQuote(command, startIndex) {
+    for (let index = startIndex; index < command.length; index += 1) {
+        if (command[index] === "\\")
+            index += 1;
+        else if (command[index] === '"')
+            return index;
+    }
+    return -1;
+}
+function transformOrderedShellVariables(command) {
+    const variables = new Map();
+    const result = [];
+    let quote = null;
+    let doubleQuoteStart = -1;
+    let doubleQuoteResultIndex = -1;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "single") {
+            result.push(character + (command[index + 1] ?? ""));
+            index += 1;
+            continue;
+        }
+        if (character === "'") {
+            if (quote !== "double")
+                quote = quote === "single" ? null : "single";
+            result.push(character);
+            continue;
+        }
+        if (character === '"') {
+            if (quote !== "single") {
+                if (quote === "double") {
+                    quote = null;
+                    doubleQuoteStart = -1;
+                    doubleQuoteResultIndex = -1;
+                }
+                else {
+                    quote = "double";
+                    doubleQuoteStart = index;
+                    doubleQuoteResultIndex = result.length;
+                }
+            }
+            result.push(character);
+            continue;
+        }
+        if (quote === null && /[A-Za-z_]/.test(character) && shellAssignmentPosition(command, index)) {
+            const arrayAssignment = shellMatchAt(SHELL_ARRAY_ASSIGNMENT, command, index);
+            if (arrayAssignment) {
+                const [, name, operator, body] = arrayAssignment;
+                const elements = parseShellWords(body);
+                if (elements === undefined)
+                    variables.delete(name);
+                else
+                    variables.set(name, { array: operator === "+=" ? [...(variables.get(name)?.array ?? []), ...elements] : elements });
+                result.push(`${name}=__OURO_ARRAY_LITERAL`);
+                index += arrayAssignment[0].length - 1;
+                continue;
+            }
+            const indexedAssignment = shellMatchAt(SHELL_INDEXED_ASSIGNMENT, command, index);
+            if (indexedAssignment) {
+                const [, name, elementIndex, rawValue] = indexedAssignment;
+                const element = parseShellWords(rawValue);
+                if (element?.length !== 1)
+                    variables.delete(name);
+                else {
+                    const array = [...(variables.get(name)?.array ?? [])];
+                    array[Number(elementIndex)] = element[0];
+                    variables.set(name, { array });
+                }
+                result.push(`${name}=__OURO_ARRAY_LITERAL`);
+                index += indexedAssignment[0].length - 1;
+                continue;
+            }
+            const scalarAssignment = shellMatchAt(SHELL_SCALAR_ASSIGNMENT, command, index);
+            if (scalarAssignment) {
+                const [, name, rawValue] = scalarAssignment;
+                const scalar = parseShellWords(rawValue);
+                if (shellAssignmentPersists(command, index + scalarAssignment[0].length)) {
+                    if (scalar?.length === 1)
+                        variables.set(name, { scalar: scalar[0] });
+                    else
+                        variables.delete(name);
+                }
+                result.push(scalarAssignment[0]);
+                index += scalarAssignment[0].length - 1;
+                continue;
+            }
+        }
+        if (quote !== "single" && character === "$") {
+            const arrayExpansion = shellMatchAt(SHELL_ARRAY_PARAMETER, command, index);
+            if (arrayExpansion) {
+                const [, name, mode] = arrayExpansion;
+                const elements = variables.get(name)?.array;
+                if (elements === undefined)
+                    result.push(SHELL_ARRAY_EXPANSION);
+                else if (quote === "double" && mode === "@") {
+                    const closing = closingDoubleQuote(command, index + arrayExpansion[0].length);
+                    const prefix = doubleQuotedFragment(command.slice(doubleQuoteStart + 1, index));
+                    const suffix = closing < 0 ? undefined : doubleQuotedFragment(command.slice(index + arrayExpansion[0].length, closing));
+                    if (closing < 0 || prefix === undefined || suffix === undefined)
+                        result.push(SHELL_ARRAY_EXPANSION);
+                    else {
+                        const presentElements = elements.filter((element) => element !== undefined);
+                        const expanded = presentElements.length === 0
+                            ? (prefix.length + suffix.length === 0 ? [] : [`${prefix}${suffix}`])
+                            : presentElements.map((element, elementIndex) => `${elementIndex === 0 ? prefix : ""}${element}${elementIndex === presentElements.length - 1 ? suffix : ""}`);
+                        result.splice(doubleQuoteResultIndex);
+                        result.push((0, shell_quote_1.quote)(expanded));
+                        quote = null;
+                        doubleQuoteStart = -1;
+                        doubleQuoteResultIndex = -1;
+                        index = closing;
+                        continue;
+                    }
+                }
+                else if (quote === "double")
+                    result.push(elements.join(" "));
+                else
+                    result.push(shellUnquotedFields(elements));
+                index += arrayExpansion[0].length - 1;
+                continue;
+            }
+            const scalarExpansion = shellMatchAt(SHELL_SCALAR_PARAMETER, command, index);
+            if (scalarExpansion) {
+                const name = scalarExpansion[1] ?? scalarExpansion[2];
+                const scalar = variables.get(name)?.scalar;
+                if (scalar !== undefined) {
+                    if (quote === "double")
+                        result.push(scalar.replace(/["\\$`]/g, "\\$&"));
+                    else
+                        result.push(shellUnquotedFields([scalar]));
+                    index += scalarExpansion[0].length - 1;
+                    continue;
+                }
+                if (quote === null) {
+                    result.push(SHELL_ARRAY_EXPANSION);
+                    index += scalarExpansion[0].length - 1;
+                    continue;
+                }
+            }
+        }
+        result.push(character);
+    }
+    return result.join("");
+}
+function findCommandSubstitutionEnd(command, start) {
+    let depth = 1;
+    let quote = null;
+    for (let index = start; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "single") {
+            index += 1;
+            continue;
+        }
+        if (character === "'" && quote !== "double") {
+            quote = quote === "single" ? null : "single";
+            continue;
+        }
+        if (character === '"' && quote !== "single") {
+            quote = quote === "double" ? null : "double";
+            continue;
+        }
+        if (quote !== null)
+            continue;
+        if (character === "(")
+            depth += 1;
+        else if (character === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function exposeShellSubstitutions(command, depth = 0) {
+    if (depth >= 32)
+        return "ouro mail sync-cache";
+    let outer = "";
+    const nested = [];
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "single") {
+            outer += character + (command[index + 1] ?? "");
+            index += 1;
+            continue;
+        }
+        if (character === "'" && quote !== "double") {
+            quote = quote === "single" ? null : "single";
+            outer += character;
+            continue;
+        }
+        if (character === '"' && quote !== "single") {
+            quote = quote === "double" ? null : "double";
+            outer += character;
+            continue;
+        }
+        if (quote !== "single" && command.startsWith("$(", index) && !command.startsWith("$((", index)) {
+            const end = findCommandSubstitutionEnd(command, index + 2);
+            if (end >= 0) {
+                nested.push(exposeShellSubstitutions(command.slice(index + 2, end), depth + 1));
+                outer += "${__OURO_COMMAND_SUBSTITUTION}";
+                index = end;
+                continue;
+            }
+        }
+        if (quote !== "single" && character === "`") {
+            let end = index + 1;
+            while (end < command.length && command[end] !== "`") {
+                if (command[end] === "\\")
+                    end += 1;
+                end += 1;
+            }
+            if (end < command.length) {
+                nested.push(exposeShellSubstitutions(command.slice(index + 1, end), depth + 1));
+                outer += "${__OURO_COMMAND_SUBSTITUTION}";
+                index = end;
+                continue;
+            }
+        }
+        outer += character;
+    }
+    return [outer, ...nested].join("\n");
+}
+function normalizeShellNewlines(command) {
+    let result = "";
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "single") {
+            result += character + (command[index + 1] ?? "");
+            index += 1;
+            continue;
+        }
+        if (character === "'" && quote !== "double")
+            quote = quote === "single" ? null : "single";
+        else if (character === '"' && quote !== "single")
+            quote = quote === "double" ? null : "double";
+        result += character === "\n" && quote === null ? " ; " : character;
+    }
+    return result;
+}
+function executableShellView(command) {
+    const withoutData = stripShellComments(stripHereDocBodies(command));
+    return normalizeShellNewlines(transformOrderedShellVariables(exposeShellSubstitutions(withoutData)));
+}
+function parseShellCommands(command) {
+    let parameterIndex = 0;
+    const parameterNames = new Map();
+    const entries = (0, shell_quote_1.parse)(command, (name) => {
+        const marker = `${SHELL_PARAMETER_MARKER}${parameterIndex}__`;
+        parameterIndex += 1;
+        parameterNames.set(marker, name);
+        return marker;
+    });
+    const commands = [];
+    let current = [];
+    let skipRedirectionTarget = false;
+    const flush = () => {
+        if (current.length > 0)
+            commands.push(current);
+        current = [];
+        skipRedirectionTarget = false;
+    };
+    for (const entry of entries) {
+        if (typeof entry === "string") {
+            if (skipRedirectionTarget)
+                skipRedirectionTarget = false;
+            else if (SHELL_TOKEN_BOUNDARIES.has(entry.toLowerCase()))
+                flush();
+            else
+                current.push(entry);
+            continue;
+        }
+        const operation = entry;
+        if (operation.op === "glob") {
+            current.push(operation.pattern);
+            continue;
+        }
+        if (SHELL_COMMAND_BOUNDARIES.has(operation.op)) {
+            flush();
+            continue;
+        }
+        // Every remaining control operator is a redirection. Its next string is
+        // a path or descriptor, not an argv token.
+        skipRedirectionTarget = true;
+    }
+    flush();
+    return { commands, parameterNames };
+}
+function resolveKnownShellParameters(token, knownVariables, parameterNames) {
+    let resolved = token;
+    for (const [marker, name] of parameterNames) {
+        const known = knownVariables.get(name);
+        if (known !== undefined)
+            resolved = resolved.replaceAll(marker, known);
+    }
+    return resolved;
+}
+function shellTokenCanEqual(token, expected) {
+    const escaped = token
+        .split(new RegExp(`(?:${SHELL_PARAMETER_MARKER}\\d+__|${SHELL_ARRAY_EXPANSION})`, "g"))
+        .map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join(".*");
+    return new RegExp(`^${escaped}$`, "i").test(expected);
+}
+function shellExecutableCanEqual(token, expected) {
+    const basenameToken = token.slice(token.lastIndexOf("/") + 1);
+    return shellTokenCanEqual(basenameToken, expected);
+}
+function exactShellExecutable(token) {
+    if (token === undefined || token.includes(SHELL_PARAMETER_MARKER))
+        return undefined;
+    return token.slice(token.lastIndexOf("/") + 1).toLowerCase();
+}
+const SUDO_SHORT_OPERANDS = new Set(["-C", "-D", "-g", "-h", "-p", "-R", "-r", "-T", "-t", "-U", "-u"]);
+const SUDO_LONG_OPERANDS = new Set(["--chdir", "--chroot", "--close-from", "--command-timeout", "--group", "--host", "--other-user", "--prompt", "--role", "--type", "--user"]);
+const TIME_SHORT_OPERANDS = new Set(["-f", "-o"]);
+const TIME_LONG_OPERANDS = new Set(["--format", "--output"]);
+function wrapperOptionAdvance(option, shortOperands, longOperands) {
+    if (shortOperands.has(option) || longOperands.has(option))
+        return 2;
+    if ([...shortOperands].some((candidate) => option.startsWith(candidate) && option.length > candidate.length))
+        return 1;
+    if ([...longOperands].some((candidate) => option.startsWith(`${candidate}=`)))
+        return 1;
+    return 0;
+}
+function resolveShellCommand(tokens, startIndex) {
+    let index = startIndex;
+    while (index < tokens.length) {
+        const executable = exactShellExecutable(tokens[index]);
+        if (SHELL_GRAMMAR_PREFIXES.has(executable ?? "")) {
+            index += 1;
+            continue;
+        }
+        if (executable === "coproc") {
+            index += 1;
+            const candidate = tokens[index] ?? "";
+            if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(candidate) && !shellExecutableCanEqual(candidate, "ouro") && tokens[index + 1] !== undefined)
+                index += 1;
+            continue;
+        }
+        if (executable === "command" || executable === "nohup") {
+            index += 1;
+            if (executable === "command" && (tokens[index] === "-v" || tokens[index] === "-V"))
+                return { index: tokens.length };
+            while (tokens[index]?.startsWith("-"))
+                index += 1;
+            continue;
+        }
+        if (executable === "env") {
+            index += 1;
+            while (index < tokens.length) {
+                const option = tokens[index];
+                if (option === "-S" || option === "--split-string")
+                    return { index, script: `env ${tokens.slice(index + 1).join(" ")}` };
+                if (option.startsWith("--split-string="))
+                    return { index, script: `env ${[option.slice("--split-string=".length), ...tokens.slice(index + 1)].join(" ")}` };
+                if (["-u", "-C", "--unset", "--chdir"].includes(option))
+                    index += 2;
+                else if (option.startsWith("-") || /^[A-Za-z_][A-Za-z0-9_]*=/.test(option))
+                    index += 1;
+                else
+                    break;
+            }
+            continue;
+        }
+        if (executable === "sudo") {
+            index += 1;
+            while (tokens[index]?.startsWith("-")) {
+                const advance = wrapperOptionAdvance(tokens[index], SUDO_SHORT_OPERANDS, SUDO_LONG_OPERANDS);
+                index += advance === 0 ? 1 : advance;
+            }
+            continue;
+        }
+        if (executable === "time") {
+            index += 1;
+            while (tokens[index]?.startsWith("-")) {
+                const advance = wrapperOptionAdvance(tokens[index], TIME_SHORT_OPERANDS, TIME_LONG_OPERANDS);
+                index += advance === 0 ? 1 : advance;
+            }
+            continue;
+        }
+        if (executable === "exec") {
+            index += 1;
+            while (tokens[index]?.startsWith("-"))
+                index += tokens[index] === "-a" ? 2 : 1;
+            continue;
+        }
+        break;
+    }
+    return { index };
+}
+function shellScriptRequiresFamily(script, variables, depth) {
+    if (script.includes(SHELL_PARAMETER_MARKER) || script.includes(SHELL_ARRAY_EXPANSION))
+        return true;
+    return shellCommandsContainMailCacheSync(script, variables, depth + 1);
+}
+function shellTokensContainMailCacheSync(tokens, startIndex, variables, depth) {
+    const resolved = resolveShellCommand(tokens, startIndex);
+    if (resolved.script !== undefined)
+        return shellScriptRequiresFamily(resolved.script, variables, depth);
+    const executableToken = tokens[resolved.index] ?? "";
+    const executable = exactShellExecutable(executableToken);
+    if (executableToken.includes(SHELL_ARRAY_EXPANSION))
+        return true;
+    if (SHELL_INTERPRETERS.has(executable ?? "")) {
+        const commandOption = tokens.findIndex((token, index) => index > resolved.index && /^-[^-]*c/.test(token));
+        return commandOption >= 0
+            && shellScriptRequiresFamily(tokens[commandOption + 1] ?? "", variables, depth);
+    }
+    if (executable === "eval")
+        return shellScriptRequiresFamily(tokens.slice(resolved.index + 1).join(" "), variables, depth);
+    return shellExecutableCanEqual(executableToken, "ouro")
+        && shellTokenCanEqual(tokens[resolved.index + 1] ?? "", "mail")
+        && shellTokenCanEqual(tokens[resolved.index + 2] ?? "", "sync-cache");
+}
+function shellCommandsContainMailCacheSync(command, inheritedVariables = new Map(), depth = 0) {
+    if (depth >= 32)
+        return true;
+    let parsed;
+    try {
+        parsed = parseShellCommands(command);
+    }
+    catch {
+        return false;
+    }
+    const knownVariables = new Map(inheritedVariables);
+    for (const rawTokens of parsed.commands) {
+        const tokens = rawTokens.map((token) => resolveKnownShellParameters(token, knownVariables, parsed.parameterNames));
+        const invocationVariables = new Map(knownVariables);
+        let commandIndex = 0;
+        while (commandIndex < tokens.length) {
+            const assignment = tokens[commandIndex].match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s);
+            if (!assignment)
+                break;
+            if (assignment[2].includes(SHELL_PARAMETER_MARKER))
+                invocationVariables.delete(assignment[1]);
+            else
+                invocationVariables.set(assignment[1], assignment[2]);
+            commandIndex += 1;
+        }
+        if (commandIndex === tokens.length) {
+            knownVariables.clear();
+            for (const [name, value] of invocationVariables)
+                knownVariables.set(name, value);
+            continue;
+        }
+        if (shellTokensContainMailCacheSync(tokens, commandIndex, invocationVariables, depth))
+            return true;
+    }
+    return false;
+}
+function shellContainsMailCacheSync(command) {
+    const executableCommand = executableShellView(command);
+    if (shellContainsAmbiguousAnsiMailCacheSync(executableCommand))
+        return true;
+    return shellCommandsContainMailCacheSync(executableCommand);
+}
+function mailCacheSyncShellGuardrail(toolName, args, context) {
+    if (toolName !== "shell" || !shellContainsMailCacheSync(args.command ?? ""))
+        return allow;
+    if (context.trustLevel === undefined || context.trustLevel === "family")
+        return allow;
+    return deny("hosted mail cache convergence requires family trust.");
+}
+function mailTrustGuardrail(toolName, args, context) {
+    if (MAIL_FAMILY_TOOLS.has(toolName)) {
+        if (context.trustLevel === undefined || context.trustLevel === "family")
+            return allow;
+        if (toolName === "mail_send")
+            return deny("outbound mail sends require family trust.");
+        return deny(toolName === "mail_decide"
+            ? "mail screener decisions require family trust."
+            : "delegated human mail requires family trust.");
+    }
+    if (MAIL_DELEGATED_READ_TOOLS.has(toolName)) {
+        const scope = (args.scope ?? "").trim().toLowerCase();
+        if (scope === "delegated" || scope === "all") {
+            if (context.trustLevel === undefined || context.trustLevel === "family")
+                return allow;
+            return deny("delegated human mail requires family trust.");
+        }
+    }
+    return allow;
+}
+function checkCredentialTrustGuardrails(toolName, context) {
+    if (CREDENTIAL_FAMILY_TOOLS.has(toolName) || COMMERCE_FAMILY_TOOLS.has(toolName)) {
+        if (context.trustLevel === "family")
+            return allow;
+        return deny(REASONS.needsTrust);
+    }
+    if (CREDENTIAL_TRUSTED_TOOLS.has(toolName) || TRAVEL_TRUSTED_TOOLS.has(toolName) || A2A_TRUSTED_TOOLS.has(toolName)) {
+        if ((0, friends_1.isTrustedLevel)(context.trustLevel))
+            return allow;
+        return deny(REASONS.needsTrust);
+    }
+    return allow;
+}
+function checkCommerceAuthorityGuardrails(toolName, args, context) {
+    if (!COMMERCE_AUTHORITY_TOOLS.has(toolName))
+        return allow;
+    if (!context.agentRoot)
+        return deny("commerce authority unavailable: agent root could not be resolved.");
+    const result = (0, store_1.validateCommerceAuthority)({
+        agentRoot: context.agentRoot,
+        token: args.commerce_authority,
+        toolName,
+        args,
+        friendId: context.friendId,
+    });
+    if (result.ok)
+        return allow;
+    return deny(`commerce authority required: ${result.reason}`);
+}
+function checkFirstClassMcpTrust(context) {
+    if (!context.mcpServerName)
+        return allow;
+    const rules = MCP_SERVER_TRUST[context.mcpServerName] ?? { minTrust: "friend", blockGroupChat: false };
+    if (!trustLevelSatisfied(rules.minTrust, context.trustLevel ?? "friend")) {
+        return deny(REASONS.needsTrust);
+    }
+    if (rules.blockGroupChat && context.isGroupChat) {
+        return deny("browser tools are only available in 1:1 conversations, not group chats.");
+    }
+    return allow;
+}
 function checkTrustLevelGuardrails(toolName, args, context) {
-    // Trusted levels (family/friend) — no trust guardrails. Undefined defaults to friend.
-    if ((0, types_1.isTrustedLevel)(context.trustLevel))
+    const cacheSyncResult = mailCacheSyncShellGuardrail(toolName, args, context);
+    if (!cacheSyncResult.allowed)
+        return cacheSyncResult;
+    const mailResult = mailTrustGuardrail(toolName, args, context);
+    if (!mailResult.allowed)
+        return mailResult;
+    if (SHEPHERD_FAMILY_TOOLS.has(toolName) && context.trustLevel !== "family") {
+        return deny("the owner's terminals require family trust.");
+    }
+    // Credential tools have their own trust rules that apply at all levels
+    const credentialResult = checkCredentialTrustGuardrails(toolName, context);
+    if (!credentialResult.allowed)
+        return credentialResult;
+    const commerceAuthorityResult = checkCommerceAuthorityGuardrails(toolName, args, context);
+    if (!commerceAuthorityResult.allowed)
+        return commerceAuthorityResult;
+    // First-class MCP tool trust (e.g. browser_navigate) — applies at all trust levels
+    const firstClassMcpResult = checkFirstClassMcpTrust(context);
+    if (!firstClassMcpResult.allowed)
+        return firstClassMcpResult;
+    // MCP server-specific trust via shell (e.g. ouro mcp call browser) — applies at all trust levels
+    if (toolName === "shell") {
+        const mcpResult = checkMcpServerTrust(args.command || "", context);
+        if (!mcpResult.allowed)
+            return mcpResult;
+    }
+    // Trusted levels (family/friend) — no further trust guardrails. Undefined defaults to friend.
+    if ((0, friends_1.isTrustedLevel)(context.trustLevel))
         return allow;
     if (toolName === "shell") {
         return checkShellTrustGuardrails(args.command || "", context.trustLevel);